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
250,000
void (int index) { SpliceInstruction instruction = new SpliceInstruction(0); instruction.setIndex(index); myInstructions.set(index, instruction); }
makeNop
250,001
DfaValueFactory () { return myFactory; }
getFactory
250,002
Set<PsiElement> (@NotNull BitSet reached) { Set<PsiElement> result = new HashSet<>(); myElementToStartOffsetMap.forEach((element, start) -> { int end = myElementToEndOffsetMap.getOrDefault(element, -1); if (end == -1) return; int nextReached = reached.nextSetBit(start); if (nextReached == -1 || nextReached >= end) { re...
computeUnreachable
250,003
boolean (@NotNull DfaVariableValue variable) { return variable.getDescriptor() instanceof Synthetic; }
isTempVariable
250,004
DfaVariableValue (@NotNull DfType dfType) { return getFactory().getVarFactory().createVariableValue(new Synthetic(getInstructionCount(), dfType)); }
createTempVariable
250,005
List<DfaVariableValue> (PsiElement element) { int startOffset = getStartOffset(element).getInstructionOffset(); List<DfaVariableValue> synthetics = new ArrayList<>(); for (DfaValue value : myFactory.getValues()) { if (value instanceof DfaVariableValue var) { VariableDescriptor descriptor = var.getDescriptor(); if (desc...
getSynthetics
250,006
String () { return String.valueOf(getInstructionOffset()); }
toString
250,007
int () { return myOffset; }
getInstructionOffset
250,008
int () { if (myOffset == -1) { throw new IllegalStateException("Not set"); } return myOffset; }
getInstructionOffset
250,009
void (int offset) { if (myOffset != -1) { throw new IllegalStateException("Already set"); } else { myOffset = offset; } }
setOffset
250,010
String () { return myOffset == -1 ? "<not set>" : super.toString(); }
toString
250,011
int () { return myElementMap.getInt(myElement); }
getInstructionOffset
250,012
String () { return "tmp$" + myLocation; }
toString
250,013
DfType (@Nullable DfaVariableValue qualifier) { return myType; }
getDfType
250,014
boolean () { return true; }
isStable
250,015
DerivedVariableDescriptor () { return myDerivedVariableDescriptor; }
getDerivedVariableDescriptor
250,016
DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { DfaValue value = arguments[0]; if (value instanceof DfaBinOpValue) { value = factory.fromDfType(state.getDfType(value)); } return factory.getWrapperFactory().createWrapper(myTargetType, myDerivedVariab...
eval
250,017
String () { return "WRAP [" + myDerivedVariableDescriptor + "] " + myTargetType; }
toString
250,018
List<PsiElement> () { return myClosures; }
getClosureElements
250,019
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { for (PsiElement element : getClosureElements()) { interpreter.createClosureState(element, stateBefore); } return nextStates(interpreter, stateBefore); }
accept
250,020
String () { return "CLOSURE"; }
toString
250,021
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState state) { if (!myVarsToFlush.isEmpty()) { for (DfaVariableValue value : myVarsToFlush) { state.flushVariable(value, false); } } return nextStates(interpreter, state); }
accept
250,022
Instruction (@NotNull DfaValueFactory factory) { if (myVarsToFlush.isEmpty()) return this; var instruction = new FinishElementInstruction(myElement); for (DfaVariableValue var : myVarsToFlush) { instruction.myVarsToFlush.add(var.bindToFactory(factory)); } return instruction; }
bindToFactory
250,023
List<DfaVariableValue> (DfaValueFactory factory) { return List.copyOf(myVarsToFlush); }
getWrittenVariables
250,024
String () { return "FINISH " + (myElement == null ? "" : myElement) + (myVarsToFlush.isEmpty() ? "" : "; flushing " + myVarsToFlush); }
toString
250,025
Set<DfaVariableValue> () { return myVarsToFlush; }
getVarsToFlush
250,026
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { stateBefore.pop(); return nextStates(interpreter, stateBefore); }
accept
250,027
String () { return "POP"; }
toString
250,028
DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { return myDerivedVariableDescriptor.createValue(factory, arguments[0]); }
eval
250,029
String () { return "UNWRAP " + myDerivedVariableDescriptor; }
toString
250,030
List<Instruction> (Instruction ins) { return IntStreamEx.of(ins.getSuccessorIndexes()).elements(myInstructions).toList(); }
getSuccessors
250,031
boolean (boolean forward, BiFunction<? super Instruction, ? super BitSet, ? extends BitSet> handleState) { List<Instruction> entryPoints; if (forward) { entryPoints = List.of(myInstructions[0]); } else { entryPoints = StreamEx.of(myInstructions).select(ControlTransferInstruction.class) .filter(cti -> cti.getTransfer()....
runDfa
250,032
DfType () { return myValue; }
getValue
250,033
DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { return factory.fromDfType(myValue); }
eval
250,034
String () { return "PUSH_VAL " + myValue; }
toString
250,035
Instruction (@NotNull DfaValueFactory factory) { return new PushInstruction(getValue().bindToFactory(factory), getDfaAnchor()); }
bindToFactory
250,036
List<DfaVariableValue> (DfaValueFactory factory) { return ContainerUtil.createMaybeSingletonList(tryCast(myValue, DfaVariableValue.class)); }
getRequiredVariables
250,037
DfaValue () { return myValue; }
getValue
250,038
DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { return myValue; }
eval
250,039
String () { return "PUSH " + myValue; }
toString
250,040
Instruction (@NotNull DfaValueFactory factory) { if (myTransferValue == null) return this; return new EnsureInstruction(myProblem, myRelation, myCompareTo, myTransferValue.bindToFactory(factory)); }
bindToFactory
250,041
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { DfaValue tosValue = stateBefore.isEmptyStack() ? interpreter.getFactory().getUnknown() : stateBefore.peek(); DfaCondition cond = createCondition(tosValue); UnsatisfiedConditionProblem problem = getProblem(); if (cond...
accept
250,042
DfaCondition (@NotNull DfaValue tosValue) { return tosValue.cond(myRelation, myCompareTo); }
createCondition
250,043
String () { return "ENSURE " + myRelation + " " + myCompareTo + (myTransferValue == null ? "" : " " + myTransferValue.getTarget()); }
toString
250,044
void (int index) { if (myIndex != -1) { throw new IllegalStateException("Index is already set: old = " + myIndex + "; new = " + index); } myIndex = index; }
setIndex
250,045
int () { return myIndex; }
getIndex
250,046
List<DfaVariableValue> (DfaValueFactory factory) { return Collections.emptyList(); }
getWrittenVariables
250,047
List<DfaVariableValue> (DfaValueFactory factory) { return Collections.emptyList(); }
getRequiredVariables
250,048
boolean () { int[] indexes = getSuccessorIndexes(); return indexes.length == 1 && indexes[0] == myIndex + 1; }
isLinear
250,049
Instruction (@NotNull DfaValueFactory factory) { return this; }
bindToFactory
250,050
DfaInstructionState (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState memState) { return new DfaInstructionState(interpreter.getInstruction(getIndex() + 1), memState); }
nextState
250,051
DfaControlTransferValue () { return myTransfer; }
getTransfer
250,052
Instruction (@NotNull DfaValueFactory factory) { return new ControlTransferInstruction(myTransfer.bindToFactory(factory), false); }
bindToFactory
250,053
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { return myTransfer.dispatch(stateBefore, interpreter).toArray(DfaInstructionState.EMPTY_ARRAY); }
accept
250,054
String () { int[] indexes = getSuccessorIndexes(); return "TRANSFER " + myTransfer + (indexes.length == 0 ? "" : " [targets: " + Arrays.toString(indexes) + "]"); }
toString
250,055
int () { return myOperands; }
getOperands
250,056
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { int operands = getOperands(); DfaValue[] args; if (operands == 0) { args = DfaValue.EMPTY_ARRAY; } else { args = new DfaValue[operands]; for (int i = operands - 1; i >= 0; i--) { args[i] = stateBefore.pop(); } } DfaV...
accept
250,057
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { stateBefore.flushFields(); return nextStates(interpreter, stateBefore); }
accept
250,058
String () { return "FLUSH_ALL_FIELDS"; }
toString
250,059
Instruction () { return myInstruction; }
getInstruction
250,060
DfaInstructionState[] (DataFlowInterpreter interpreter) { return myInstruction.nextStates(interpreter, myBeforeMemoryState); }
nextStates
250,061
DfaMemoryState () { return myBeforeMemoryState; }
getMemoryState
250,062
String () { return getInstruction().getIndex() + " " + getInstruction() + ": " + getMemoryState(); }
toString
250,063
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; DfaInstructionState state = (DfaInstructionState)o; return Objects.equals(myBeforeMemoryState, state.myBeforeMemoryState) && Objects.equals(myInstruction, state.myInstruction); }
equals
250,064
int () { return 31 * myBeforeMemoryState.hashCode() + myInstruction.hashCode(); }
hashCode
250,065
int (@NotNull DfaInstructionState o) { return Integer.compare(myInstruction.getIndex(), o.myInstruction.getIndex()); }
compareTo
250,066
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { List<DfaValue> removed = IntStreamEx.range(myCount).mapToObj(idx -> stateBefore.pop()).toList(); IntStreamEx.of(myReplacement).elements(removed).forEach(stateBefore::push); Instruction nextInstruction = interpreter.g...
accept
250,067
String () { return "SPLICE [" + myCount + "] -> " + Arrays.toString(myReplacement); }
toString
250,068
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { DfaCondition condTrue = stateBefore.pop().eq(myCompareTo); DfaCondition condFalse = condTrue.negate(); if (condTrue == DfaCondition.getTrue()) { return new DfaInstructionState[] {new DfaInstructionState(interpreter.g...
accept
250,069
String () { return "IF_EQ " + myCompareTo + " " + getOffset(); }
toString
250,070
boolean (@NotNull DfType valueOnStack, @NotNull Instruction target) { return target.getIndex() == (valueOnStack.equals(myCompareTo) ? getOffset() : getIndex() + 1); }
isTarget
250,071
int () { return myOffset.getInstructionOffset(); }
getOffset
250,072
void (final int offset) { myOffset = new ControlFlow.FixedOffset(offset); }
setOffset
250,073
DfaVariableValue () { return myDestination; }
getDestination
250,074
Instruction (@NotNull DfaValueFactory factory) { return new SimpleAssignmentInstruction(getDfaAnchor(), myDestination.bindToFactory(factory)); }
bindToFactory
250,075
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { DfaValue value = stateBefore.pop(); interpreter.getListener().beforeAssignment(value, myDestination, stateBefore, getDfaAnchor()); stateBefore.setVarValue(myDestination, value); pushResult(interpreter, stateBefore, m...
accept
250,076
List<DfaVariableValue> (DfaValueFactory factory) { return List.of(myDestination); }
getWrittenVariables
250,077
String () { return "ASSIGN_TO " + myDestination; }
toString
250,078
boolean (Instruction instruction) { if (instruction == myInstructions[0]) return true; if (!instruction.getRequiredVariables(myFactory).isEmpty() || !instruction.getWrittenVariables(myFactory).isEmpty()) return true; return !instruction.isLinear() || instruction instanceof FinishElementInstruction; }
isInterestingInstruction
250,079
void (DfaVariableValue value) { if (!newVars.get(value.getID())) { if (!cloned) { newVars = (BitSet)newVars.clone(); cloned = true; } newVars.set(value.getID()); } }
accept
250,080
void (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState state, @NotNull DfType value, @NotNull DfaValue @NotNull ... inputArgs) { pushResult(interpreter, state, interpreter.getFactory().fromDfType(value), inputArgs); }
pushResult
250,081
void (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState state, @NotNull DfaValue value, @NotNull DfaValue @NotNull ... inputArgs) { DfaAnchor anchor = getDfaAnchor(); if (anchor != null) { interpreter.getListener().beforePush(inputArgs, value, anchor, state); } state.push(value); }
pushResult
250,082
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { final DfaValue a = stateBefore.pop(); final DfaValue b = stateBefore.pop(); stateBefore.push(a); stateBefore.push(b); return nextStates(interpreter, stateBefore); }
accept
250,083
String () { return "SWAP"; }
toString
250,084
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState memState) { memState.push(memState.peek()); return nextStates(interpreter, memState); }
accept
250,085
String () { return "DUP"; }
toString
250,086
boolean () { return myShouldWiden; }
shouldWidenBackBranch
250,087
int () { return myOffset.getInstructionOffset(); }
getOffset
250,088
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { Instruction nextInstruction = interpreter.getInstruction(getOffset()); return new DfaInstructionState[]{new DfaInstructionState(nextInstruction, stateBefore)}; }
accept
250,089
String () { return "GOTO " + getOffset(); }
toString
250,090
void (final int offset) { myOffset = new ControlFlow.FixedOffset(offset); }
setOffset
250,091
Instruction (@NotNull DfaValueFactory factory) { return new FlushVariableInstruction(myVariable.bindToFactory(factory)); }
bindToFactory
250,092
DfaVariableValue () { return myVariable; }
getVariable
250,093
List<DfaVariableValue> (DfaValueFactory factory) { return List.of(myVariable); }
getWrittenVariables
250,094
DfaInstructionState[] (@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) { stateBefore.flushVariable(getVariable()); return nextStates(interpreter, stateBefore); }
accept
250,095
String () { return "FLUSH " + myVariable; }
toString
250,096
Instruction (@NotNull DfaValueFactory factory) { return new ReturnInstruction(getTransfer().bindToFactory(factory), myAnchor, false); }
bindToFactory
250,097
String () { int[] indexes = getSuccessorIndexes(); return "RETURN" + (indexes.length == 0 ? "" : " [traps: " + Arrays.toString(indexes) + "]"); }
toString
250,098
LongRangeSet (long value) { return subtract(point(value)); }
without
250,099
boolean () { return this == Empty.EMPTY; }
isEmpty