Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
249,800 | boolean () { return this == UNKNOWN; } | isUnknown |
249,801 | Exact (boolean value) { return value ? TRUE : FALSE; } | fromBoolean |
249,802 | DfaRelation () { return new DfaRelation(leftOperand, rightOperand, relationType.getNegated()); } | negate |
249,803 | DfaCondition (boolean result) { DfaValue newLeft = leftOperand; DfaValue newRight = rightOperand; if (newLeft instanceof DfaTypeValue leftTypeValue) { newLeft = newLeft.getFactory().fromDfType(leftTypeValue.getDfType().correctForRelationResult(relationType, result)); } if (newRight instanceof DfaTypeValue rightTypeValu... | correctForRelationResult |
249,804 | boolean () { return leftOperand instanceof DfaTypeValue && rightOperand instanceof DfaTypeValue; } | isUnknown |
249,805 | DfaRelation (@NotNull DfaValue dfaLeft, @NotNull RelationType relationType, @NotNull DfaValue dfaRight) { if (dfaLeft instanceof DfaVariableValue || dfaLeft instanceof DfaWrappedValue || dfaLeft instanceof DfaBinOpValue || dfaRight instanceof DfaVariableValue || dfaRight instanceof DfaWrappedValue || dfaRight instanceo... | createRelation |
249,806 | boolean () { return relationType == RelationType.EQ; } | isEquality |
249,807 | DfaVariableValue () { return myLeft; } | getLeft |
249,808 | DfaValue () { return myRight; } | getRight |
249,809 | DfaValue (@NotNull DfaValueFactory factory) { return factory.getBinOpFactory().doCreate(myLeft.bindToFactory(factory), myRight.bindToFactory(factory), myType, myOp); } | bindToFactory |
249,810 | DfIntegralType () { return myType; } | getDfType |
249,811 | boolean (DfaVariableValue other) { return myLeft.dependsOn(other) || myRight.dependsOn(other); } | dependsOn |
249,812 | LongRangeBinOp () { return myOp; } | getOperation |
249,813 | String () { String delimiter = myOp.toString(); if (myOp == LongRangeBinOp.PLUS && myRight instanceof DfaTypeValue) { long value = extractLong((DfaTypeValue)myRight); if (value < 0) { delimiter = ""; } } return myLeft + delimiter + myRight; } | toString |
249,814 | long (DfaTypeValue right) { return Objects.requireNonNull(right.getDfType().getConstantOfType(Number.class)).longValue(); } | extractLong |
249,815 | record (long hash, LongRangeBinOp op, DfType type) {} | Key |
249,816 | DfaValue (DfaValue left, DfaValue right, DfaMemoryState state, DfIntegralType resultType, LongRangeBinOp op) { if (op == null) return myFactory.getUnknown(); DfaValue value = doCreate(left, right, state, resultType, op); if (value != null) { return value; } DfIntegralType leftType = ObjectUtils.tryCast(state.getDfType(... | create |
249,817 | boolean (@NotNull DfaMemoryState state, @NotNull DfaValue dividend, @NotNull DfaValue divisor, @NotNull LongRangeSet dividendRange, @NotNull LongRangeSet divisorRange) { if (divisorRange.min() > 0) { // a % b where 0 <= a < b if (dividendRange.min() > -divisorRange.max() && dividendRange.max() >= 0 && (dividendRange.ma... | withinDivisorRange |
249,818 | DfaBinOpValue (DfaVariableValue left, DfaValue right, DfIntegralType resultType, LongRangeBinOp op) { long hash = ((long)left.getID() << 32) | right.getID(); Key key = new Key(hash, op, resultType); return myValues.computeIfAbsent(key, k -> new DfaBinOpValue(left, right, resultType, op)); } | doCreate |
249,819 | boolean (RelationType other) { if (other == this) return true; return switch (this) { case LE -> other == LT || other == EQ; case GE -> other == GT || other == EQ; case NE -> other == LT || other == GT; default -> false; }; } | isSubRelation |
249,820 | RelationType () { return switch (this) { case LE -> GT; case LT -> GE; case GE -> LT; case GT -> LE; case EQ -> NE; case NE -> EQ; case IS -> IS_NOT; case IS_NOT -> IS; }; } | getNegated |
249,821 | boolean () { return this == LE || this == GE || this == LT || this == GT || this == NE; } | isInequality |
249,822 | String () { return myName; } | toString |
249,823 | RelationType (boolean equal) { return equal ? EQ : NE; } | equivalence |
249,824 | DfaVariableValue () { return myWrappedValue; } | getWrappedValue |
249,825 | DerivedVariableDescriptor () { return myDerivedVariableDescriptor; } | getSpecialField |
249,826 | DfaValue (@NotNull DfaValueFactory factory) { return factory.getWrapperFactory().createWrapper(myType, myDerivedVariableDescriptor, myWrappedValue.bindToFactory(factory)); } | bindToFactory |
249,827 | boolean (DfaVariableValue other) { return myWrappedValue.dependsOn(other); } | dependsOn |
249,828 | DfType () { return myType; } | getDfType |
249,829 | DfaValue (@NotNull DfType qualifierType, @NotNull DerivedVariableDescriptor specialField, @NotNull DfaValue specialFieldValue) { if (specialFieldValue instanceof DfaVariableValue && ((DfaVariableValue)specialFieldValue).getDescriptor() == specialField) { DfaVariableValue qualifier = ((DfaVariableValue)specialFieldValue... | createWrapper |
249,830 | String () { return target + (traps.isEmpty() ? "" : " " + traps); } | toString |
249,831 | DfaControlTransferValue (DfaValueFactory factory) { return factory.controlTransfer(target.bindToFactory(factory), traps); } | bindToFactory |
249,832 | TransferTarget () { return target; } | getTarget |
249,833 | FList<Trap> () { return traps; } | getTraps |
249,834 | List<DfaInstructionState> (@NotNull DfaMemoryState state, @NotNull DataFlowInterpreter interpreter) { return dispatch(state, interpreter, target, traps); } | dispatch |
249,835 | List<DfaInstructionState> (@NotNull DfaMemoryState state, @NotNull DataFlowInterpreter interpreter, @NotNull TransferTarget target, @NotNull FList<Trap> nextTraps) { Trap head = nextTraps.getHead(); nextTraps = nextTraps.getTail() == null ? FList.emptyList() : nextTraps.getTail(); state.emptyStack(); if (head != null) ... | dispatch |
249,836 | String () { return "Return"; } | toString |
249,837 | void (@NotNull PsiElement context) { myContext = context; for (DfaValue value : myValues) { if (value instanceof DfaVariableValue) { ((DfaVariableValue)value).resetInherentType(); } } } | setContext |
249,838 | DfaValue (int id) { return myValues.get(id); } | getValue |
249,839 | DfaTypeValue () { return fromDfType(DfType.TOP); } | getUnknown |
249,840 | DfaValue () { return mySentinelValue; } | getSentinel |
249,841 | Project () { return myProject; } | getProject |
249,842 | DfaTypeValue (@NotNull DfType dfType) { return myTypeValueFactory.create(dfType); } | fromDfType |
249,843 | Collection<DfaValue> () { return Collections.unmodifiableCollection(myValues); } | getValues |
249,844 | DfaControlTransferValue (TransferTarget kind, FList<Trap> traps) { return myControlTransfers.get(Pair.create(kind, traps)); } | controlTransfer |
249,845 | DfaValue (@NotNull DfaValueFactory factory) { return factory.mySentinelValue; } | bindToFactory |
249,846 | String () { return "SENTINEL"; } | toString |
249,847 | int () { return mySize; } | size |
249,848 | boolean () { return mySize == 0; } | isEmpty |
249,849 | void (int val) { int pos = indexOf(val); if (pos >= 0) return; if (mySize == myData.length) { myData = Arrays.copyOf(myData, mySize * 3 / 2 + 1); } System.arraycopy(myData, -pos - 1, myData, -pos, mySize + pos + 1); myData[-pos - 1] = val; mySize++; } | add |
249,850 | void (int[] vals) { for (int val : vals) { add(val); } } | add |
249,851 | boolean (int val) { return indexOf(val) >= 0; } | contains |
249,852 | void (int val) { int pos = indexOf(val); if (pos >= 0) { remove(pos); } } | removeValue |
249,853 | int (int value) { for (int i = 0; i < mySize; i++) { int datum = myData[i]; if (value == datum) return i; if (value < datum) return -i - 1; } return - mySize - 1; } | indexOf |
249,854 | void (int offset) { System.arraycopy(myData, offset + 1, myData, offset, mySize - offset - 1); mySize--; } | remove |
249,855 | boolean (SortedIntSet that) { int thatSize = that.size(); int thisSize = this.size(); if (thatSize > thisSize) return false; int thisIndex=0; for (int thatIndex = 0; thatIndex < thatSize; thatIndex++) { int thatValue = that.myData[thatIndex]; while (thisIndex < thisSize && this.myData[thisIndex] < thatValue) { thisInde... | containsAll |
249,856 | int (SortedIntSet t) { if (t == this) return 0; if (t.size() != size()) return Integer.compare(size(), t.size()); for (int i = 0; i < size(); i++) { if (myData[i] != t.myData[i]) return Integer.compare(myData[i], t.myData[i]); } return 0; } | compareTo |
249,857 | int (int pos) { if (pos >= mySize) throw new IllegalArgumentException(); return myData[pos]; } | get |
249,858 | void (IntConsumer consumer) { for (int i = 0; i < mySize; i++) { consumer.accept(myData[i]); } } | forValues |
249,859 | boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; SortedIntSet set = (SortedIntSet)o; if (mySize != set.mySize) return false; return Arrays.equals(myData, 0, mySize, set.myData, 0, mySize); } | equals |
249,860 | int () { int size = mySize; int result = Objects.hash(size); int[] arr = myData; for (int i = 0; i < size; i++) { int element = arr[i]; result = 31 * result + element; } return result; } | hashCode |
249,861 | int[] () { return Arrays.copyOf(myData, mySize); } | toNativeArray |
249,862 | boolean (int firstIndex, int secondIndex) { LongOpenHashSet toAdd = new LongOpenHashSet(); LongOpenHashSet toRemove = new LongOpenHashSet(); toAdd.add(createPair(firstIndex, secondIndex, true)); toRemove.add(createPair(firstIndex, secondIndex, false)); for(DistinctPair pair : this) { if (!pair.isOrdered()) continue; if... | addOrdered |
249,863 | void (int firstIndex, int secondIndex) { if (!myData.contains(createPair(firstIndex, secondIndex, true)) && !myData.contains(createPair(secondIndex, firstIndex, true))) { myData.add(createPair(firstIndex, secondIndex, false)); } } | addUnordered |
249,864 | boolean (Object o) { if (o instanceof DistinctPair dp) { return myData.remove(createPair(dp.myFirst, dp.mySecond, dp.myOrdered)); } return false; } | remove |
249,865 | boolean (Object o) { if (!(o instanceof DistinctPair dp)) return false; EqClass first = dp.getFirst(); EqClass second = dp.getSecond(); if (first.isEmpty() || second.isEmpty()) return false; int firstVal = first.get(0); int secondVal = second.get(0); int firstIndex = myState.getEqClassIndex(myState.getFactory().getValu... | contains |
249,866 | Iterator<DistinctPair> () { return new Iterator<>() { final LongIterator iterator = myData.iterator(); @Override public boolean hasNext() { return iterator.hasNext(); } @Override public DistinctPair next() { return decode(iterator.nextLong()); } @Override public void remove() { iterator.remove(); } }; } | iterator |
249,867 | boolean () { return iterator.hasNext(); } | hasNext |
249,868 | DistinctPair () { return decode(iterator.nextLong()); } | next |
249,869 | void () { iterator.remove(); } | remove |
249,870 | int () { return myData.size(); } | size |
249,871 | boolean (int c1Index, int c2Index) { LongArrayList c2Pairs = new LongArrayList(); long[] distincts = myData.toLongArray(); for (long distinct : distincts) { int pc1 = low(distinct); int pc2 = high(distinct); boolean addedToC1 = false; if (pc1 == c1Index || pc2 == c1Index) { addedToC1 = true; if (distinct < 0) { if (pc1... | unite |
249,872 | void (int index, int[] splitIndices) { LongArrayList toAdd = new LongArrayList(); for(LongIterator iterator = myData.iterator(); iterator.hasNext(); ) { DistinctPair pair = decode(iterator.nextLong()); if (pair.myFirst == index) { for (int splitIndex : splitIndices) { toAdd.add(createPair(splitIndex, pair.mySecond, pai... | splitClass |
249,873 | boolean (int c1Index, int c2Index) { return myData.contains(createPair(c1Index, c2Index, false)); } | areDistinctUnordered |
249,874 | DistinctPair (long encoded) { boolean ordered = encoded < 0; encoded = Math.abs(encoded); return new DistinctPair(low(encoded), high(encoded), ordered, myState.getEqClasses()); } | decode |
249,875 | void (DistinctPair pair) { if (remove(pair)) { addUnordered(pair.myFirst, pair.mySecond); } } | dropOrder |
249,876 | long (int low, int high, boolean ordered) { if (ordered) { return -(((long)high << 32) + low); } return low < high ? ((long)low << 32) + high : ((long)high << 32) + low; } | createPair |
249,877 | int (long l) { return (int)(Math.abs(l)); } | low |
249,878 | int (long l) { return (int)((Math.abs(l) & 0xFFFFFFFF00000000L) >> 32); } | high |
249,879 | EqClass () { return myList.get(myFirst); } | getFirst |
249,880 | int () { return myFirst; } | getFirstIndex |
249,881 | EqClass () { return myList.get(mySecond); } | getSecond |
249,882 | int () { return mySecond; } | getSecondIndex |
249,883 | void () { if (myList.get(myFirst) == null) { throw new IllegalStateException(this + ": EqClass " + myFirst + " is missing"); } if (myList.get(mySecond) == null) { throw new IllegalStateException(this + ": EqClass " + mySecond + " is missing"); } } | check |
249,884 | boolean () { return myOrdered; } | isOrdered |
249,885 | boolean (Object obj) { if (obj == this) return true; if (!(obj instanceof DistinctPair that)) return false; if (that.myOrdered != this.myOrdered) return false; return that.getFirst().equals(this.getFirst()) && that.getSecond().equals(this.getSecond()) || (!myOrdered && that.getSecond().equals(this.getFirst()) && that.g... | equals |
249,886 | int () { return getFirst().hashCode() * (myOrdered ? 31 : 1) + getSecond().hashCode(); } | hashCode |
249,887 | String () { return "{" + myList.get(myFirst) + (myOrdered ? "<" : "!=") + myList.get(mySecond) + "}"; } | toString |
249,888 | DfaValueFactory () { return myFactory; } | getFactory |
249,889 | DfaMemoryStateImpl () { return new DfaMemoryStateImpl(this); } | createCopy |
249,890 | DfaMemoryStateImpl () { DfaMemoryStateImpl copy = createCopy(); copy.flushFields(new QualifierStatusMap(null, true)); copy.emptyStack(); for (DfaValue value : getFactory().getValues().toArray(DfaValue.EMPTY_ARRAY)) { if (value instanceof DfaVariableValue var) { DfType type = copy.getDfType(var); DfType newType = type.c... | createClosureState |
249,891 | boolean (Object obj) { if (obj == this) return true; if (!(obj instanceof DfaMemoryStateImpl that)) return false; if (myCachedHash != null && that.myCachedHash != null && !myCachedHash.equals(that.myCachedHash)) return false; return myEphemeral == that.myEphemeral && myStack.equals(that.myStack) && getNonTrivialEqClass... | equals |
249,892 | DistinctPairSet () { return myDistinctClasses; } | getDistinctClassPairs |
249,893 | LinkedHashSet<EqClass> () { if (myCachedNonTrivialEqClasses != null) return myCachedNonTrivialEqClasses; LinkedHashSet<EqClass> result = new LinkedHashSet<>(); for (EqClass eqClass : myEqClasses) { if (eqClass != null && eqClass.size() > 1) { result.add(eqClass); } } return myCachedNonTrivialEqClasses = result; } | getNonTrivialEqClasses |
249,894 | int () { if (myCachedHash != null) return myCachedHash; int hash = ((getNonTrivialEqClasses().hashCode() * 31 + getDistinctClassPairs().hashCode()) * 31 + myStack.hashCode()) * 31 + myVariableTypes.hashCode(); return myCachedHash = hash; } | hashCode |
249,895 | String () { StringBuilder result = new StringBuilder(); result.append('<'); if (myEphemeral) { result.append("ephemeral, "); } for (EqClass set : getNonTrivialEqClasses()) { result.append(set); } if (!myDistinctClasses.isEmpty()) { result.append("\n distincts: "); String distincts = StreamEx.of(getDistinctClassPairs())... | toString |
249,896 | DfaValue () { myCachedHash = null; return myStack.pop(); } | pop |
249,897 | DfaValue () { return myStack.peek(); } | peek |
249,898 | int () { return myStack.size(); } | getStackSize |
249,899 | void (@NotNull DfaValue value) { assert value.getFactory() == myFactory : value; myCachedHash = null; myStack.push(value); } | push |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.