Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
249,900 | void () { while (!myStack.isEmpty() && !(myStack.peek() instanceof DfaControlTransferValue)) { myCachedHash = null; myStack.pop(); } } | emptyStack |
249,901 | void (DfaVariableValue var, DfaValue value) { assert value.getFactory() == myFactory; assert var.getFactory() == myFactory; if (var == value) return; value = handleStackValueOnVariableFlush(value, var, null); flushVariable(var, var.getDfType().isMergeable(var.getInherentType())); flushQualifiedMethods(var); DfType dfTy... | setVarValue |
249,902 | DfType (DfaVariableValue var, @NotNull DfType dfType) { return dfType; } | filterDfTypeOnAssignment |
249,903 | DfaValue (DfaValue value, DfaVariableValue flushed, DfaVariableValue replacement) { if (value.dependsOn(flushed)) { DfType dfType = getDfType(value); if (value instanceof DfaVariableValue var && replacement != null) { DfaVariableValue target = replaceQualifier(var, flushed, replacement); if (target != value) return tar... | handleStackValueOnVariableFlush |
249,904 | int (@NotNull DfaVariableValue dfaValue) { int i = getEqClassIndex(dfaValue); if (i != -1) return i; dfaValue = canonicalize(dfaValue); EqClass eqClass = new EqClass(myFactory); eqClass.add(dfaValue.getID()); int resultIndex = storeClass(eqClass); checkInvariants(); return resultIndex; } | getOrCreateEqClassIndex |
249,905 | int (EqClass eqClass) { int freeIndex = myEqClasses.indexOf(null); int resultIndex = freeIndex >= 0 ? freeIndex : myEqClasses.size(); if (freeIndex >= 0) { myEqClasses.set(freeIndex, eqClass); } else { myEqClasses.add(eqClass); } eqClass.forValues(id -> myIdToEqClassesIndices.put(id, resultIndex)); return resultIndex; ... | storeClass |
249,906 | boolean (@NotNull DfaMemoryState other) { if (!(other instanceof DfaMemoryStateImpl that)) return false; if (myEphemeral && !that.myEphemeral) return false; if (myStack.size() != that.myStack.size()) return false; for (int i = 0; i < myStack.size(); i++) { if (!isSuperValue(myStack.get(i), that.myStack.get(i))) return ... | isSuperStateOf |
249,907 | boolean (DfaValue superValue, DfaValue subValue) { if (DfaTypeValue.isUnknown(superValue) || superValue == subValue) return true; if (superValue instanceof DfaTypeValue && subValue instanceof DfaTypeValue) { return superValue.getDfType().isMergeable(subValue.getDfType()); } return false; } | isSuperValue |
249,908 | List<EqClass> () { return myEqClasses; } | getEqClasses |
249,909 | int (@NotNull DfaValue dfaValue) { int classIndex = myIdToEqClassesIndices.getOrDefault(dfaValue.getID(), -1); if (classIndex == -1) { dfaValue = canonicalize(dfaValue); classIndex = myIdToEqClassesIndices.getOrDefault(dfaValue.getID(), -1); } if (classIndex == -1) return -1; EqClass aClass = myEqClasses.get(classIndex... | getEqClassIndex |
249,910 | boolean (DfaVariableValue val1, DfaVariableValue val2) { DfaVariableValue var1 = getCanonicalVariable(val1); DfaVariableValue var2 = getCanonicalVariable(val2); int c1Index = getOrCreateEqClassIndex(val1); int c2Index = getOrCreateEqClassIndex(val2); if (c1Index == c2Index) return true; if (!myDistinctClasses.unite(c1I... | uniteClasses |
249,911 | DfaVariableValue (DfaVariableValue variable, DfaVariableValue from, DfaVariableValue to) { DfaVariableValue qualifier = variable.getQualifier(); if (qualifier != null) { return variable.withQualifier(replaceQualifier(qualifier == from ? to : qualifier, from, to)); } return variable; } | replaceQualifier |
249,912 | boolean (DfaVariableValue from, DfaVariableValue to) { assert from != to; if (from.getDependentVariables().isEmpty()) return true; List<DfaVariableValue> vars = new ArrayList<>(myVariableTypes.keySet()); for (DfaVariableValue var : vars) { DfaVariableValue target = replaceQualifier(var, from, to); if (target != var) { ... | convertQualifiers |
249,913 | void () { if (!LOG.isDebugEnabled() && !ApplicationManager.getApplication().isEAP()) return; for (Int2IntMap.Entry entry : myIdToEqClassesIndices.int2IntEntrySet()) { EqClass eqClass = myEqClasses.get(entry.getIntValue()); if (eqClass == null || !eqClass.contains(entry.getIntKey())) { LOG.error("Invariant violated: nul... | checkInvariants |
249,914 | boolean (int v, Int2ObjectMap<BitSet> graph, BitSet visited, BitSet stack) { if (!visited.get(v)) { visited.set(v); stack.set(v); BitSet set = graph.get(v); if (set != null && set.stream().anyMatch(i -> !visited.get(i) && isCycle(i, graph, visited, stack) || stack.get(i))) { return true; } } stack.clear(v); return fals... | isCycle |
249,915 | void () { myEphemeral = true; } | markEphemeral |
249,916 | boolean () { return myEphemeral; } | isEphemeral |
249,917 | boolean () { return myStack.isEmpty(); } | isEmptyStack |
249,918 | void (@NotNull DfaValue value, @NotNull DfType dfType) { if (value instanceof DfaVariableValue) { recordVariableType((DfaVariableValue)value, dfType); } } | setDfType |
249,919 | void (@NotNull DfaValue value, @NotNull UnaryOperator<@NotNull DfType> updater) { if (!(value instanceof DfaVariableValue var)) return; EqClass values = getEqClass(var); Iterable<DfaVariableValue> vars = values == null ? List.of(var) : values; for (@NotNull DfaVariableValue eqVar : vars) { DfType type = getRecordedType... | updateDfType |
249,920 | boolean (@NotNull DfaValue value, @NotNull DfType dfType) { if (dfType == DfType.TOP) return true; if (dfType == DfType.BOTTOM) return false; if (value instanceof DfaBinOpValue) { return propagateRangeBack(ObjectUtils.tryCast(dfType, DfIntegralType.class), (DfaBinOpValue)value); } if (value instanceof DfaVariableValue ... | meetDfType |
249,921 | boolean (@NotNull DfaVariableValue var, @NotNull DfType originalType, @NotNull DfType newType) { recordVariableType(var, newType); for (Map.Entry<DerivedVariableDescriptor, DfType> entry : newType.getDerivedValues().entrySet()) { if (!meetDfType(entry.getKey().createValue(getFactory(), var), entry.getValue())) { return... | meetVariableType |
249,922 | boolean (@Nullable DfIntegralType appliedRange, @NotNull DfaBinOpValue binOp) { if (appliedRange == null) return true; DfaVariableValue left = binOp.getLeft(); DfaValue right = binOp.getRight(); DfIntegralType leftDfType = ObjectUtils.tryCast(getDfType(left), DfIntegralType.class); DfIntegralType rightDfType = ObjectUt... | propagateRangeBack |
249,923 | boolean (@NotNull DfaCondition condition) { if (condition instanceof DfaRelation relation) { if (relation.isEquality()) { checkEphemeral(relation.leftOperand(), relation.rightOperand()); checkEphemeral(relation.rightOperand(), relation.leftOperand()); } } return applyCondition(condition); } | applyContractCondition |
249,924 | boolean (@NotNull DfaValue value1, @NotNull DfaValue value2) { if (value1 instanceof DfaBinOpValue binOp1 && value2 instanceof DfaBinOpValue binOp2) { return binOp1.getOperation() == binOp2.getOperation() && areEqual(binOp1.getLeft(), binOp2.getLeft()) && areEqual(binOp1.getRight(), binOp2.getRight()); } DfType dfType1... | areEqual |
249,925 | boolean (@NotNull DfaCondition dfaCond) { if (!(dfaCond instanceof DfaRelation)) { return dfaCond != DfaCondition.getFalse(); } return applyRelationCondition((DfaRelation)dfaCond); } | applyCondition |
249,926 | boolean (@NotNull DfaRelation dfaRelation) { DfaValue dfaLeft = dfaRelation.leftOperand(); DfaValue dfaRight = dfaRelation.rightOperand(); RelationType relationType = dfaRelation.relationType(); if (DfaTypeValue.isUnknown(dfaLeft) || DfaTypeValue.isUnknown(dfaRight)) return true; // Such relations are only useful to up... | applyRelationCondition |
249,927 | LongRangeSet (@NotNull DfType type) { return type instanceof DfIntegralType ? ((DfIntegralType)type).getRange() : LongRangeSet.all(); } | extractRange |
249,928 | boolean (DfaValue left, RelationType type, DfaValue right) { if (type != RelationType.LT && type != RelationType.GT && type != RelationType.NE && type != RelationType.EQ) return true; if (!(left instanceof DfaBinOpValue binOp)) { if (right instanceof DfaBinOpValue) { return applyBinOpRelations(right, type.getFlipped(),... | applyBinOpRelations |
249,929 | boolean (@NotNull RelationType type, @NotNull DfaVariableValue left, @NotNull LongRangeSet leftRange, @NotNull LongRangeSet rightRange, @NotNull DfaValue sum, @NotNull LongRangeType lrType) { if (!leftRange.additionMayOverflow(rightRange, lrType)) { // a-positiveNumber >= b => a > b if (rightRange.max() < 0 && Relation... | applyRelationOnAddition |
249,930 | RelationType (RelationType relation, LongRangeSet summand1, LongRangeSet summand2, LongRangeSet resultRange, LongRangeType lrType) { if (relation != RelationType.LT && relation != RelationType.GT) return relation; boolean overflowPossible = true; if (lrType.bytes() < 8) { LongRangeSet overflowRange = getSumOverflowValu... | correctRelation |
249,931 | LongRangeSet (LongRangeSet left, LongRangeSet right, LongRangeType lrType) { if (left.isEmpty() || right.isEmpty()) return LongRangeSet.empty(); long sumMin = left.min() + right.min(); long sumMax = left.max() + right.max(); LongRangeSet result = LongRangeSet.empty(); if (sumMin < lrType.min()) { result = result.join(L... | getSumOverflowValues |
249,932 | boolean (RelationType type, DfaValue dfaLeft, DfaValue dfaRight) { RelationType currentRelation = getRelation(dfaLeft, dfaRight); if (currentRelation != null) { // Eq: NE & GE => GT type = type.meet(currentRelation); if (type == null) return false; } boolean isNegated = type == RelationType.NE || type == RelationType.G... | applyEquivalenceRelation |
249,933 | void (DfaValue left, DfaValue right) { } | checkEphemeral |
249,934 | boolean (DfaVariableValue target, DfaValue value) { DfType constraint = target.getDescriptor().getQualifierConstraintFromValue(this, value); DfaVariableValue qualifier = target.getQualifier(); return qualifier == null || meetDfType(qualifier, constraint); } | updateQualifierOnEquality |
249,935 | boolean (DfaVariableValue value, DfConstantType<?> constant) { DfType dfType = constant.tryNegate(); if (dfType == null) return true; EqClass eqClass = getEqClass(value); if (eqClass == null) return true; for (DistinctPairSet.DistinctPair pair : getDistinctClassPairs().toArray(new DistinctPairSet.DistinctPair[0])) { Eq... | propagateConstant |
249,936 | boolean (@NotNull DfaValue value, @NotNull DfType type) { EqClass eqClass = getEqClass(value); if (eqClass == null) return true; if (type.fromRelation(RelationType.GT) == DfType.TOP && type.fromRelation(RelationType.LT) == DfType.TOP) return true; DistinctPairSet distinctPairs = myDistinctClasses; myDistinctClasses = n... | correctRelatedValues |
249,937 | boolean (@NotNull DfaValue left, @NotNull DfaValue right) { return StreamEx.of(left, right).flatCollection(val -> val.getDfType().getDerivedVariables()) .allMatch(field -> { DfaValue leftValue = field.createValue(myFactory, left); DfaValue rightValue = field.createValue(myFactory, right); DfType result = getDfType(left... | applyDerivedVariablesEquivalence |
249,938 | boolean (@NotNull DfaValue dfaLeft, DfaValue dfaRight) { if (getDfType(dfaLeft).meet(getDfType(dfaRight)) == DfType.BOTTOM) return true; List<DerivedVariableDescriptor> variables = new ArrayList<>(dfaLeft.getDfType().getDerivedVariables()); variables.retainAll(dfaRight.getDfType().getDerivedVariables()); return StreamE... | applyDerivedInequality |
249,939 | boolean (@NotNull DfaValue dfaLeft, @NotNull DfaValue dfaRight, boolean isNegated) { if (!(dfaLeft instanceof DfaVariableValue) || !(dfaRight instanceof DfaVariableValue)) return true; if (!isNegated && (isUnstableValue(dfaLeft) || isUnstableValue(dfaRight))) return true; int c1Index = getOrCreateEqClassIndex((DfaVaria... | applyRelation |
249,940 | boolean (@NotNull DfaValue dfaLeft, @NotNull DfaValue dfaRight) { if (!(dfaLeft instanceof DfaVariableValue) || !(dfaRight instanceof DfaVariableValue)) return true; int c1Index = getOrCreateEqClassIndex((DfaVariableValue)dfaLeft); int c2Index = getOrCreateEqClassIndex((DfaVariableValue)dfaRight); if (c1Index == c2Inde... | applyLessThanRelation |
249,941 | boolean (DfaValue value) { if (!(value instanceof DfaVariableValue var)) return false; return !var.alwaysEqualsToItself(getDfType(var)); } | isUnstableValue |
249,942 | DfType (DfaBinOpValue binOp) { DfIntegralType leftType = ObjectUtils.tryCast(getDfType(binOp.getLeft()), DfIntegralType.class); DfIntegralType rightType = ObjectUtils.tryCast(getDfType(binOp.getRight()), DfIntegralType.class); if (leftType == null || rightType == null) return binOp.getDfType(); LongRangeSet left = left... | getBinOpRange |
249,943 | DfType (@NotNull DfaValue value) { DfType newType = getDfType(value); if (value instanceof DfaVariableValue var) { var = canonicalizeQualifier(var); if (!var.getDependentVariables().isEmpty()) { for (Map.Entry<DfaVariableValue, DfType> entry : myVariableTypes.entrySet()) { DfaVariableValue recordedVar = entry.getKey();... | getDfTypeIncludingDerived |
249,944 | DfType (@NotNull DfaValue value) { if (value instanceof DfaBinOpValue binOpValue) { return getBinOpRange(binOpValue); } if (value instanceof DfaVariableValue variableValue) { DfType type = getRecordedType(variableValue); return type != null ? type : variableValue.getInherentType(); } if (value instanceof DfaWrappedValu... | getDfType |
249,945 | void (@NotNull DfaVariableValue dfaVar, @NotNull DfType type) { dfaVar = canonicalize(dfaVar); type = type.getBasicType(); if (type.equals(dfaVar.getInherentType())) { myVariableTypes.remove(dfaVar); } else { myVariableTypes.put(dfaVar, type); } if (type instanceof DfEphemeralType) { markEphemeral(); } myCachedHash = n... | recordVariableType |
249,946 | boolean (DfaVariableValue dfaVar, DfType type) { if (!updateQualifierOnEquality(dfaVar, dfaVar)) return false; EqClass eqClass = getEqClass(dfaVar); if (eqClass != null) { type = type.fromRelation(RelationType.EQ); for (DfaVariableValue value : eqClass.asList()) { if (value != dfaVar) { recordVariableType(value, type.m... | updateDependentVariables |
249,947 | DfaValue (@NotNull DfaValue value) { if (value instanceof DfaVariableValue) { return canonicalize((DfaVariableValue)value); } if (value instanceof DfaWrappedValue boxedValue) { DfaValue canonicalized = canonicalize(boxedValue.getWrappedValue()); if (canonicalized == boxedValue.getWrappedValue()) return boxedValue; retu... | canonicalize |
249,948 | DfaVariableValue (DfaVariableValue var) { DfaVariableValue qualifier = var.getQualifier(); if (qualifier != null) { return var.withQualifier(canonicalizeQualifier(qualifier)); } return var; } | canonicalize |
249,949 | DfaVariableValue (@NotNull DfaVariableValue qualifier) { int index = myIdToEqClassesIndices.getOrDefault(qualifier.getID(), -1); if (index == -1) { qualifier = canonicalize(qualifier); index = myIdToEqClassesIndices.getOrDefault(qualifier.getID(), -1); if (index == -1) { return qualifier; } } return Objects.requireNonN... | canonicalizeQualifier |
249,950 | DfType (DfaVariableValue var) { DfType type = myVariableTypes.get(var); if (type != null) { return type; } DfaVariableValue canonicalized = canonicalize(var); return canonicalized == var ? null : myVariableTypes.get(canonicalized); } | getRecordedType |
249,951 | void (BiConsumer<? super DfaVariableValue, ? super DfType> consumer) { myVariableTypes.forEach(consumer); } | forRecordedVariableTypes |
249,952 | void (@NotNull Set<DfaValue> qualifiers) { flushFields(new QualifierStatusMap(qualifiers, false)); } | flushFieldsQualifiedBy |
249,953 | void () { flushFields(new QualifierStatusMap(null, false)); } | flushFields |
249,954 | void (@NotNull DfaMemoryStateImpl.QualifierStatusMap qualifierStatusMap) { Set<DfaVariableValue> vars = new LinkedHashSet<>(); for (DfaVariableValue value : myVariableTypes.keySet()) { if (qualifierStatusMap.shouldFlush(value)) { vars.add(value); } } for (EqClass aClass : myEqClasses) { if (aClass != null) { for (DfaVa... | flushFields |
249,955 | void (@NotNull DfaVariableValue variable) { flushVariable(variable, true); } | flushVariable |
249,956 | void (@NotNull Predicate<? super @NotNull DfaVariableValue> filter) { Set<DfaVariableValue> vars = new HashSet<>(); for (EqClass aClass : myEqClasses) { if (aClass != null) { for (DfaVariableValue value : aClass) { vars.add(value); } } } vars.addAll(myVariableTypes.keySet()); vars.removeIf(filter.negate()); vars.forEac... | flushVariables |
249,957 | void (@NotNull DfaVariableValue variable, boolean canonicalize) { DfaVariableValue canonical = canonicalize ? canonicalize(variable) : variable; EqClass eqClass = canonical.getDependentVariables().isEmpty() ? null : getEqClass(canonical); DfaVariableValue newCanonical = eqClass == null ? null : StreamEx.of(eqClass.iter... | flushVariable |
249,958 | void (@NotNull DfaVariableValue variable) { if (variable.isFlushableByCalls()) { // Flush method results on field write List<DfaVariableValue> toFlush = StreamEx.of(myEqClasses).flatMap(cls -> cls == null ? null : StreamEx.of(cls.iterator())) .append(myVariableTypes.keySet()).filter(DfaVariableValue::containsCalls).toL... | flushQualifiedMethods |
249,959 | void (@NotNull DfaVariableValue var, boolean markFlushed) { DfType typeBefore = getDfType(var); removeEquivalence(var); myVariableTypes.remove(var); if (markFlushed) { DfType inherentType = var.getInherentType(); DfType correctedType = inherentType.correctTypeOnFlush(typeBefore); if (!inherentType.equals(correctedType)... | doFlush |
249,960 | Object () { /* States are mergeable if: - Ephemeral flag is the same - Stack depth is the same - All DfaControlTransferValues in the stack are the same (otherwise finally blocks may not complete successfully) - All sentinels in the stack are the same (otherwise we may screw up the unrolled loops) - Top-of-stack value i... | getMergeabilityKey |
249,961 | void (@NotNull DfaMemoryState that) { DfaMemoryStateImpl other = (DfaMemoryStateImpl)that; assert other.isEphemeral() == isEphemeral(); assert other.myStack.size() == myStack.size(); ProgressManager.checkCanceled(); retainEquivalences(other); mergeDistinctPairs(other); mergeVariableTypes(other); mergeStacks(other); myC... | merge |
249,962 | void (@NotNull DfaMemoryState other) { } | afterMerge |
249,963 | void (DfaMemoryStateImpl other) { List<DfaValue> values = StreamEx.zip(myStack, other.myStack, DfaValue::unite).toList(); myStack.clear(); values.forEach(myStack::push); } | mergeStacks |
249,964 | void (DfaMemoryStateImpl other) { ArrayList<DistinctPairSet.DistinctPair> pairs = new ArrayList<>(myDistinctClasses); for (DistinctPairSet.DistinctPair pair : pairs) { EqClass first = pair.getFirst(); EqClass second = pair.getSecond(); RelationType relation = other.getRelation(myFactory.getValue(first.get(0)), myFactor... | mergeDistinctPairs |
249,965 | void (DfaMemoryStateImpl other) { Set<DfaVariableValue> vars = StreamEx.of(myVariableTypes, other.myVariableTypes).toFlatCollection(Map::keySet, HashSet::new); for (DfaVariableValue var : vars) { DfType type = getDfType(var); DfType otherType = other.getDfType(var); DfType result; if (!type.equals(otherType)) { result ... | mergeVariableTypes |
249,966 | void (DfaMemoryStateImpl other) { boolean needRestart = true; while (needRestart) { ProgressManager.checkCanceled(); needRestart = false; for (EqClass eqClass : new ArrayList<>(myEqClasses)) { if (eqClass != null && retainEquivalences(eqClass, other)) { needRestart = true; break; } } } } | retainEquivalences |
249,967 | boolean (EqClass eqClass, DfaMemoryStateImpl other) { if (eqClass.size() <= 1) return false; List<EqClass> groups = splitEqClass(eqClass, other); if (groups.size() == 1) return false; IntList addedClasses = new IntArrayList(); int origIndex = myIdToEqClassesIndices.get(eqClass.get(0)); for (EqClass group : groups) { ad... | retainEquivalences |
249,968 | List<EqClass> (EqClass eqClass, DfaMemoryStateImpl other) { Int2ObjectMap<EqClass> groupsInClasses = new Int2ObjectOpenHashMap<>(); List<EqClass> groups = new ArrayList<>(); for (DfaVariableValue value : eqClass.asList()) { int otherClass = other.getEqClassIndex(value); EqClass list; if (otherClass == -1) { list = new ... | splitEqClass |
249,969 | QualifierStatus (@NotNull DfaValue qualifier) { final DfType dfType = getDfType(qualifier); if (dfType.isImmutableQualifier()) return QualifierStatus.SHOULD_NOT_FLUSH; if (dfType.isLocal()) { return myQualifiersToFlush != null && myQualifiersToFlush.contains(qualifier) ? QualifierStatus.SHOULD_FLUSH_ALWAYS : QualifierS... | calculate |
249,970 | void () { myVariableTypes.replaceAll((var, type) -> type.widen()); } | widen |
249,971 | String () { StringBuilder buf = new StringBuilder(); buf.append("("); for (int i = 0; i < size(); i++) { if (i > 0) buf.append(", "); int value = get(i); DfaValue dfaValue = myFactory.getValue(value); buf.append(dfaValue); } buf.append(")"); return buf.toString(); } | toString |
249,972 | DfaVariableValue (int index) { return (DfaVariableValue)myFactory.getValue(get(index)); } | getVariable |
249,973 | List<DfaVariableValue> () { List<DfaVariableValue> vars = new ArrayList<>(size()); forValues(id -> vars.add((DfaVariableValue)myFactory.getValue(id))); return vars; } | asList |
249,974 | Iterator<DfaVariableValue> () { return new Iterator<>() { int pos; @Override public boolean hasNext() { return pos < size(); } @Override public DfaVariableValue next() { if (pos >= size()) throw new NoSuchElementException(); return (DfaVariableValue)myFactory.getValue(get(pos++)); } }; } | iterator |
249,975 | boolean () { return pos < size(); } | hasNext |
249,976 | DfaVariableValue () { if (pos >= size()) throw new NoSuchElementException(); return (DfaVariableValue)myFactory.getValue(get(pos++)); } | next |
249,977 | DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { return arguments[0]; } | eval |
249,978 | String () { return "RESULT_OF " + getDfaAnchor(); } | toString |
249,979 | DfaAnchor () { return Objects.requireNonNull(super.getDfaAnchor()); } | getDfaAnchor |
249,980 | Collection<Instruction> () { return Arrays.asList(myFlow.getInstructions()); } | getNodes |
249,981 | Iterator<Instruction> (Instruction n) { int[] ins = myIns.get(n.getIndex()); return indicesToInstructions(ins); } | getIn |
249,982 | Iterator<Instruction> (Instruction instruction) { int[] next = instruction.getSuccessorIndexes(); return indicesToInstructions(next); } | getOut |
249,983 | Iterator<Instruction> (int[] next) { if (next == null) return Collections.emptyIterator(); List<Instruction> out = new ArrayList<>(next.length); for (int i : next) { out.add(myInstructions[i]); } return out.iterator(); } | indicesToInstructions |
249,984 | int[] (ControlFlow controlFlow) { final int[] loop = new int[controlFlow.getInstructionCount()]; // loop[i] = loop number(strongly connected component number) of i-th instruction or 0 if outside loop MyGraph graph = new MyGraph(controlFlow); final DFSTBuilder<Instruction> builder = new DFSTBuilder<>(graph); IntList scc... | calcInLoop |
249,985 | DfaValue (@NotNull DfaValueFactory factory, @NotNull DfaMemoryState state, @NotNull DfaValue @NotNull ... arguments) { return factory.fromDfType(myResult); } | eval |
249,986 | String () { return "EVAL_UNKNOWN " + getOperands(); } | toString |
249,987 | PsiElement () { return myPsiAnchor; } | getPsiAnchor |
249,988 | Instruction[] () { return myInstructions.toArray(new Instruction[0]); } | getInstructions |
249,989 | Instruction (int index) { return myInstructions.get(index); } | getInstruction |
249,990 | int () { return myInstructions.size(); } | getInstructionCount |
249,991 | ControlFlowOffset () { return new FixedOffset(myInstructions.size()); } | getNextOffset |
249,992 | void (@NotNull PsiElement psiElement) { myElementToStartOffsetMap.put(psiElement, myInstructions.size()); } | startElement |
249,993 | void (@NotNull PsiElement psiElement) { myElementToEndOffsetMap.put(psiElement, myInstructions.size()); } | finishElement |
249,994 | void (Instruction instruction) { instruction.setIndex(myInstructions.size()); myInstructions.add(instruction); } | addInstruction |
249,995 | int[] () { return myLoopNumbers; } | getLoopNumbers |
249,996 | void () { try { addInstruction(new ReturnInstruction(myFactory, FList.emptyList(), null)); myLoopNumbers = LoopAnalyzer.calcInLoop(this); new LiveVariablesAnalyzer(this).flushDeadVariablesOnStatementFinish(); } catch (ProcessCanceledException ex) { throw ex; } catch (RuntimeException ex) { throw new RuntimeExceptionWit... | finish |
249,997 | ControlFlowOffset (final PsiElement element) { return new FromMapOffset(element, myElementToStartOffsetMap); } | getStartOffset |
249,998 | ControlFlowOffset (final PsiElement element) { return new FromMapOffset(element, myElementToEndOffsetMap); } | getEndOffset |
249,999 | String () { StringBuilder result = new StringBuilder(); final List<Instruction> instructions = myInstructions; for (int i = 0; i < instructions.size(); i++) { Instruction instruction = instructions.get(i); result.append(i).append(": ").append(instruction.toString()); result.append("\n"); } return result.toString(); } | toString |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.