Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
33,800 | Iterable<Instruction> (@NotNull CallEnvironment environment) { final Deque<CallInstruction> callStack = environment.callStack(this); if (callStack.isEmpty()) return Collections.emptyList(); //can be true in case env was not populated (e.g. by DFA) final CallInstruction callInstruction = callStack.peek(); final Iterable... | successors |
33,801 | void (@NotNull GrOpenBlock block) { final PsiElement parent = block.getParent(); final PsiElement lbrace = block.getLBrace(); if (lbrace != null && parent instanceof GrMethod) { for (GrParameter parameter : ((GrMethod)parent).getParameters()) { if (myPolicy.isVariableInitialized(parameter)) { addNode(new ReadWriteVaria... | visitOpenBlock |
33,802 | void (@NotNull GrExpressionLambdaBody body) { addFunctionalExpressionParameters(body.getLambdaExpression()); body.getExpression().accept(this); } | visitExpressionLambdaBody |
33,803 | void (@NotNull GrBlockLambdaBody body) { addFunctionalExpressionParameters(body.getLambdaExpression()); addControlFlowInstructions(body); } | visitBlockLambdaBody |
33,804 | void (@NotNull GroovyFileBase file) { super.visitFile(file); final GrStatement[] statements = file.getStatements(); if (statements.length > 0) { handlePossibleReturn(statements[statements.length - 1]); } } | visitFile |
33,805 | InstructionImpl (@NotNull GrStatement possibleReturn) { if (possibleReturn instanceof GrExpression && ControlFlowBuilderUtil.isCertainlyReturnStatement(possibleReturn)) { return addNodeAndCheckPending(new MaybeReturnInstruction((GrExpression)possibleReturn)); } return null; } | handlePossibleReturn |
33,806 | GroovyControlFlow (@NotNull GroovyPsiElement scope) { return buildControlFlow(scope, GrResolverPolicy.getInstance()); } | buildControlFlow |
33,807 | GroovyControlFlow (@NotNull GroovyPsiElement scope) { return new ControlFlowBuilder(GrResolverPolicy.getInstance(), true).doBuildFlatControlFlow(scope); } | buildFlatControlFlow |
33,808 | GroovyControlFlow (@NotNull GroovyPsiElement scope, @NotNull GrControlFlowPolicy policy) { return new ControlFlowBuilder(policy, false).doBuildControlFlow(scope); } | buildControlFlow |
33,809 | GroovyControlFlow (GroovyPsiElement scope) { var topOwner = ControlFlowUtils.getTopmostOwner(scope); if (topOwner == null) { return new GroovyControlFlow(Instruction.EMPTY_ARRAY, getDescriptorMapping()); } myFinallyCount = 0; myInstructionNumber = 0; myScope = scope; startNode(null); topOwner.accept(this); InstructionI... | doBuildFlatControlFlow |
33,810 | int (VariableDescriptor actualDescriptor) { myVariableMapping.putIfAbsent(actualDescriptor, myVariableMapping.size() + 1); return myVariableMapping.get(actualDescriptor); } | getDescriptorId |
33,811 | VariableDescriptor[] () { VariableDescriptor[] array = new VariableDescriptor[myVariableMapping.size() + 1]; for (var entry : myVariableMapping.entrySet()) { array[entry.getValue()] = entry.getKey(); } return array; } | getDescriptorMapping |
33,812 | GroovyControlFlow (GroovyPsiElement scope) { if (scope instanceof GrLambdaExpression) { GrLambdaBody body = ((GrLambdaExpression)scope).getBody(); Instruction[] flow = body != null ? body.getControlFlow() : Instruction.EMPTY_ARRAY; return new GroovyControlFlow(flow, getDescriptorMapping()); } myFinallyCount = 0; myInst... | doBuildControlFlow |
33,813 | void (final GrStatementOwner owner) { PsiElement child = owner.getFirstChild(); while (child != null) { if (child instanceof GroovyPsiElement) { ((GroovyPsiElement)child).accept(this); } child = child.getNextSibling(); } final GrStatement[] statements = owner.getStatements(); if (statements.length > 0) { handlePossible... | addControlFlowInstructions |
33,814 | void (GrFunctionalExpression expression) { for (GrParameter parameter : expression.getAllParameters()) { if (myPolicy.isVariableInitialized(parameter)) { addNode(new ReadWriteVariableInstruction(getDescriptorId(createDescriptor(parameter)), parameter, ReadWriteVariableInstruction.WRITE)); } } } | addFunctionalExpressionParameters |
33,815 | void (InstructionImpl begin, InstructionImpl end) { begin.addSuccessor(end); end.addPredecessor(begin); if (!(begin instanceof MixinTypeInstruction)) { end.addNegationsFrom(begin); } } | addEdge |
33,816 | void (@NotNull GrLambdaExpression expression) { GrLambdaBody body = expression.getBody(); if (body == null) return; if (isFlatFlow) { FunctionalBlockBeginInstruction startClosure = new FunctionalBlockBeginInstruction(expression); myFunctionalScopeStack.addLast(expression); addNode(startClosure); addPendingEdge(expressi... | visitLambdaExpression |
33,817 | void (@NotNull GrClosableBlock closure) { if (isFlatFlow) { FunctionalBlockBeginInstruction startClosure = new FunctionalBlockBeginInstruction(closure); myFunctionalScopeStack.addLast(closure); addNodeAndCheckPending(startClosure); addPendingEdge(closure, startClosure); addFunctionalExpressionParameters(closure); addCo... | visitClosure |
33,818 | void (@NotNull PsiElement anchor, List<kotlin.Pair<ReadWriteVariableInstruction, VariableDescriptor>> reads) { for (kotlin.Pair<ReadWriteVariableInstruction, VariableDescriptor> read : reads) { PsiElement element = read.getFirst().getElement(); if (!(element instanceof GrReferenceExpression) || myPolicy.isReferenceAcce... | addReadFromNestedControlFlow |
33,819 | void (@NotNull GrBreakStatement breakStatement) { super.visitBreakStatement(breakStatement); GrStatement target = breakStatement.resolveLabel(); if (target == null) target = breakStatement.findTargetStatement(); if (target != null) { if (myHead != null) { addPendingEdge(target, myHead); } readdPendingEdge(target); } in... | visitBreakStatement |
33,820 | void (@NotNull GrContinueStatement continueStatement) { super.visitContinueStatement(continueStatement); GrStatement target = continueStatement.resolveLabel(); if (target == null) target = continueStatement.findTargetStatement(); if (target != null) { final InstructionImpl instruction = findInstruction(target); if (ins... | visitContinueStatement |
33,821 | void (@NotNull GrReturnStatement returnStatement) { boolean isNodeNeeded = myHead == null || myHead.getElement() != returnStatement; final GrExpression value = returnStatement.getReturnValue(); if (value != null) value.accept(this); GroovyPsiElement scopeElement = myFunctionalScopeStack.isEmpty() ? null : returnStateme... | visitReturnStatement |
33,822 | void (@NotNull GrAssertStatement assertStatement) { final InstructionImpl assertInstruction = startNode(assertStatement); final GrExpression assertion = assertStatement.getAssertion(); if (assertion != null) { assertion.accept(this); InstructionImpl positiveHead = myHead; List<GotoInstruction> negations = collectAndRem... | visitAssertStatement |
33,823 | void (@NotNull GrThrowStatement throwStatement) { final GrExpression exception = throwStatement.getException(); if (exception == null) return; exception.accept(this); final InstructionImpl throwInstruction = new ThrowingInstruction(throwStatement); addNodeAndCheckPending(throwInstruction); interruptFlow(); final PsiTyp... | visitThrowStatement |
33,824 | PsiType (@NotNull final GrExpression expression) { if (expression instanceof GrNewExpression) { return expression.getType(); } else if (expression instanceof GrReferenceExpression && ((GrReferenceExpression)expression).getQualifier() == null) { return getTypeByRef((GrReferenceExpression)expression); } return null; } | getNominalTypeNoRecursion |
33,825 | PsiType (@NotNull GrReferenceExpression invoked) { PsiElement resolved = invoked.getStaticReference().resolve(); return resolved instanceof PsiVariable ? ((PsiVariable)resolved).getType() : null; } | getTypeByRef |
33,826 | void () { myHead = null; } | interruptFlow |
33,827 | ExceptionInfo (PsiType thrownType) { final Iterator<ExceptionInfo> iterator = myCaughtExceptionInfos.descendingIterator(); while (iterator.hasNext()) { final ExceptionInfo info = iterator.next(); final GrCatchClause clause = info.myClause; final GrParameter parameter = clause.getParameter(); if (parameter != null) { fi... | findCatch |
33,828 | void (@NotNull GrLabeledStatement labeledStatement) { final InstructionImpl instruction = startNode(labeledStatement); super.visitLabeledStatement(labeledStatement); finishNode(instruction); } | visitLabeledStatement |
33,829 | void (@NotNull GrAssignmentExpression expression) { GrExpression lValue = expression.getLValue(); if (expression.isOperatorAssignment() || expression.getOperationTokenType() == T_ELVIS_ASSIGN) { if (lValue instanceof GrReferenceExpression && myPolicy.isReferenceAccepted((GrReferenceExpression)lValue)) { VariableDescrip... | visitAssignmentExpression |
33,830 | void (@NotNull GrTupleAssignmentExpression expression) { GrExpression rValue = expression.getRValue(); if (rValue != null) { rValue.accept(this); } expression.getLValue().accept(this); } | visitTupleAssignmentExpression |
33,831 | void (@NotNull GrParenthesizedExpression expression) { final GrExpression operand = expression.getOperand(); if (operand != null) operand.accept(this); } | visitParenthesizedExpression |
33,832 | void (@NotNull GrUnaryExpression expression) { final GrExpression operand = expression.getOperand(); if (operand == null) return; if (expression.getOperationTokenType() != GroovyTokenTypes.mLNOT) { operand.accept(this); visitCall(expression); return; } FList<ConditionInstruction> conditionsBefore = myConditions; Condit... | visitUnaryExpression |
33,833 | InstructionImpl (GroovyPsiElement currentScope, List<? extends GotoInstruction> negations) { if (negations.size() > 1) { InstructionImpl instruction = addNode(new InstructionImpl(currentScope)); for (GotoInstruction negation : negations) { addEdge(negation, instruction); } return instruction; } else if (negations.size(... | reduceAllNegationsIntoInstruction |
33,834 | List<GotoInstruction> (GroovyPsiElement currentScope) { List<GotoInstruction> negations = new ArrayList<>(); for (Iterator<Pair<InstructionImpl, GroovyPsiElement>> iterator = myPending.iterator(); iterator.hasNext(); ) { Pair<InstructionImpl, GroovyPsiElement> pair = iterator.next(); InstructionImpl instruction = pair.... | collectAndRemoveAllPendingNegations |
33,835 | void (@NotNull GrInstanceOfExpression expression) { expression.getOperand().accept(this); processInstanceOf(expression, GrInstanceOfExpression.isNegated(expression)); } | visitInstanceofExpression |
33,836 | void (@NotNull GrReferenceExpression refExpr) { super.visitReferenceExpression(refExpr); if (myPolicy.isReferenceAccepted(refExpr)) { VariableDescriptor descriptor = createDescriptor(refExpr); if (descriptor == null) return; if (ControlFlowUtils.isIncOrDecOperand(refExpr)) { final InstructionImpl i = new ReadWriteVaria... | visitReferenceExpression |
33,837 | void (@NotNull GrMethodCall call) { super.visitMethodCall(call); addNodeAndCheckPending(new ArgumentsInstruction(call, myVariableMapping)); visitCall(call); } | visitMethodCall |
33,838 | void (@NotNull GrConstructorInvocation invocation) { super.visitConstructorInvocation(invocation); addNodeAndCheckPending(new ArgumentsInstruction(invocation, myVariableMapping)); visitCall(invocation); } | visitConstructorInvocation |
33,839 | void (@NotNull GrNewExpression newExpression) { super.visitNewExpression(newExpression); addNodeAndCheckPending(new ArgumentsInstruction(newExpression, myVariableMapping)); visitCall(newExpression); } | visitNewExpression |
33,840 | void (@NotNull GrBinaryExpression expression) { final GrExpression left = expression.getLeftOperand(); final GrExpression right = expression.getRightOperand(); final IElementType opType = expression.getOperationTokenType(); if (ControlFlowBuilderUtil.isInstanceOfBinary(expression)) { expression.getLeftOperand().accept(... | visitBinaryExpression |
33,841 | void (GrExpression expression, boolean negated) { FList<ConditionInstruction> conditionsBefore = myConditions; ConditionInstruction cond = registerCondition(expression, negated); addNodeAndCheckPending(cond); addNode(new InstanceOfInstruction(expression, cond, myVariableMapping)); NegatingGotoInstruction negation = new... | processInstanceOf |
33,842 | void (GroovyPsiElement call) { //optimization: don't add call instruction if there is no catch or finally block in the context if (myCaughtExceptionInfos.size() <= 0 && myFinallyCount <= 0) { return; } final InstructionImpl instruction = new ThrowingInstruction(call); addNodeAndCheckPending(instruction); for (Exception... | visitCall |
33,843 | void (@NotNull GrIfStatement ifStatement) { InstructionImpl ifInstruction = startNode(ifStatement); FList<ConditionInstruction> conditionsBefore = myConditions; final GrCondition condition = ifStatement.getCondition(); final GrStatement thenBranch = ifStatement.getThenBranch(); final GrStatement elseBranch = ifStatemen... | visitIfStatement |
33,844 | ConditionInstruction (@NotNull PsiElement element, boolean negated) { ConditionInstruction condition = new ConditionInstruction(element, negated, myConditions); myConditions = myConditions.prepend(condition); return condition; } | registerCondition |
33,845 | void (@Nullable GroovyPsiElement element) { if (element != null) { element.accept(this); } } | acceptNullable |
33,846 | void (@NotNull GrForStatement forStatement) { final GrForClause clause = forStatement.getClause(); processForLoopInitializer(clause); InstructionImpl start = startNode(forStatement); addForLoopBreakingEdge(forStatement, clause); flushForeachLoopVariable(clause); final GrStatement body = forStatement.getBody(); if (body... | visitForStatement |
33,847 | void (@Nullable GrForClause clause) { if (clause instanceof GrTraditionalForClause) { acceptNullable(((GrTraditionalForClause)clause).getInitialization()); } else if (clause instanceof GrForInClause forInClause) { acceptNullable(forInClause.getIteratedExpression()); addNodeAndCheckPending(new ReadWriteVariableInstructi... | processForLoopInitializer |
33,848 | void (GrForStatement forStatement, @Nullable GrForClause clause) { final GroovyPsiElement target = forStatement.getParent() instanceof GrLabeledStatement ? (GroovyPsiElement)forStatement.getParent() : forStatement; if (clause instanceof GrTraditionalForClause) { final GrExpression condition = ((GrTraditionalForClause)c... | addForLoopBreakingEdge |
33,849 | void (@Nullable GrForClause clause) { if (clause instanceof GrForInClause) { GrVariable variable = ((GrForInClause)clause).getDeclaredVariable(); if (variable != null && myPolicy.isVariableInitialized(variable)) { addNodeAndCheckPending(new ReadWriteVariableInstruction(getDescriptorId(new LoopIteratorVariableDescriptor... | flushForeachLoopVariable |
33,850 | void (@NotNull InstructionImpl instruction) { final PsiElement element = instruction.getElement(); checkPending(element, instruction); } | checkPending |
33,851 | void (@Nullable PsiElement currentScope, @NotNull InstructionImpl targetInstruction) { final List<Pair<InstructionImpl, GroovyPsiElement>> pendingEdges = collectCorrespondingPendingEdges(currentScope); for (Pair<InstructionImpl, GroovyPsiElement> pair : pendingEdges) { addEdge(pair.getFirst(), targetInstruction); } } | checkPending |
33,852 | void (@Nullable GroovyPsiElement newScope) { final List<Pair<InstructionImpl, GroovyPsiElement>> targets = collectCorrespondingPendingEdges(newScope); for (Pair<InstructionImpl, GroovyPsiElement> target : targets) { addPendingEdge(newScope, target.getFirst()); } } | readdPendingEdge |
33,853 | void (@Nullable GroovyPsiElement scopeWhenAdded, InstructionImpl instruction) { if (instruction == null) return; int i = 0; if (scopeWhenAdded != null) { for (; i < myPending.size(); i++) { Pair<InstructionImpl, GroovyPsiElement> pair = myPending.get(i); final GroovyPsiElement currScope = pair.getSecond(); if (currScop... | addPendingEdge |
33,854 | void (@NotNull GrWhileStatement whileStatement) { final InstructionImpl instruction = startNode(whileStatement); final GrCondition condition = whileStatement.getCondition(); if (condition != null) { condition.accept(this); } if (!alwaysTrue(condition)) { addPendingEdge(whileStatement, myHead); //break } final GrConditi... | visitWhileStatement |
33,855 | boolean (GroovyPsiElement condition) { if (condition instanceof GrExpression) { return Boolean.TRUE.equals(GroovyConstantExpressionEvaluator.evaluateNoResolve((GrExpression)condition)); } else { return false; } } | alwaysTrue |
33,856 | void (@NotNull GrSwitchElement switchElement) { final GrCondition condition = switchElement.getCondition(); if (condition != null) { condition.accept(this); } final InstructionImpl instruction = startNode(switchElement); final GrCaseSection[] sections = switchElement.getCaseSections(); if (!containsAllCases(switchEleme... | visitSwitchElement |
33,857 | void (@NotNull GrSwitchStatement switchStatement) { visitSwitchElement(switchStatement); } | visitSwitchStatement |
33,858 | void (@NotNull GrSwitchExpression switchExpression) { visitSwitchElement(switchExpression); } | visitSwitchExpression |
33,859 | void (@NotNull GrConditionalExpression expression) { GrExpression condition = expression.getCondition(); GrExpression thenBranch = expression.getThenBranch(); GrExpression elseBranch = expression.getElseBranch(); condition.accept(this); InstructionImpl conditionEnd = myHead; List<GotoInstruction> negations = collectAnd... | visitConditionalExpression |
33,860 | void (@NotNull GrElvisExpression expression) { GrExpression condition = expression.getCondition(); GrExpression elseBranch = expression.getElseBranch(); condition.accept(this); List<GotoInstruction> negations = collectAndRemoveAllPendingNegations(expression); InstructionImpl head = myHead; handlePossibleReturn(conditio... | visitElvisExpression |
33,861 | boolean (GrSwitchElement statement) { final GrCaseSection[] sections = statement.getCaseSections(); for (GrCaseSection section : sections) { if (section.isDefault()) return true; } final GrExpression condition = statement.getCondition(); if (!(condition instanceof GrReferenceExpression)) return false; PsiType type = Ty... | containsAllCases |
33,862 | void (@NotNull GrCaseSection caseSection) { for (GrExpression value : caseSection.getExpressions()) { if (value != null) { value.accept(this); } } final GrStatement[] statements = caseSection.getStatements(); //infer 'may be return' position int i; //noinspection StatementWithEmptyBody for (i = statements.length - 1; i... | visitCaseSection |
33,863 | void (GrStatement statement) { if (statement instanceof GrExpression && ControlFlowBuilderUtil.isCertainlyYieldStatement(statement)) { addNodeAndCheckPending(new MaybeYieldInstruction((GrExpression)statement)); } } | handlePossibleYield |
33,864 | void (@NotNull GrYieldStatement yieldStatement) { GrExpression value = yieldStatement.getYieldedValue(); if (value != null) { value.accept(this); } if (myHead != null) { GrSwitchElement correspondingSwitch = PsiTreeUtil.getParentOfType(yieldStatement, GrSwitchElement.class); addNode(new InstructionImpl(yieldStatement))... | visitYieldStatement |
33,865 | void (@NotNull GrTryCatchStatement tryCatchStatement) { final GrOpenBlock tryBlock = tryCatchStatement.getTryBlock(); final GrCatchClause[] catchClauses = tryCatchStatement.getCatchClauses(); final GrFinallyClause finallyClause = tryCatchStatement.getFinallyClause(); for (int i = catchClauses.length - 1; i >= 0; i--) {... | visitTryStatement |
33,866 | void () { error("broken control flow for a scope"); } | error |
33,867 | void (@NonNls @NotNull String descr) { PsiFile file = myScope.getContainingFile(); String fileText = file != null ? file.getText() : null; VirtualFile virtualFile = PsiUtilCore.getVirtualFile(file); String path = virtualFile == null ? null : virtualFile.getPresentableUrl(); LOG.error(descr + myScope.getText(), new Atta... | error |
33,868 | AfterCallInstruction (InstructionImpl finallyInstruction, GroovyPsiElement scopeWhenAdded, InstructionImpl src) { interruptFlow(); final CallInstruction call = new CallInstruction(finallyInstruction); addNode(call); addEdge(src, call); addEdge(call, finallyInstruction); AfterCallInstruction afterCall = new AfterCallIns... | addCallNode |
33,869 | InstructionImpl (@Nullable GroovyPsiElement element) { return startNode(element, true); } | startNode |
33,870 | InstructionImpl (@Nullable GroovyPsiElement element, boolean checkPending) { final InstructionImpl instruction = new InstructionImpl(element); addNode(instruction); if (checkPending) checkPending(instruction); myProcessingStack.push(instruction); return instruction; } | startNode |
33,871 | void (InstructionImpl instruction) { final InstructionImpl popped = myProcessingStack.pop(); if (!instruction.equals(popped)) { String description = "popped : " + popped.toString() + " : " + popped.hashCode() + ", " + popped.getClass() + "\n" + "expected: " + instruction.toString() + " : " + instruction.hashCode() + ",... | finishNode |
33,872 | void (@NotNull GrField field) { } | visitField |
33,873 | void (@NotNull GrParameter parameter) { if (parameter.getParent() instanceof GrForClause) { visitVariable(parameter); } } | visitParameter |
33,874 | void (@NotNull GrMethod method) { } | visitMethod |
33,875 | void (@NotNull GrClassInitializer initializer) { } | visitClassInitializer |
33,876 | void (@NotNull final GrTypeDefinition typeDefinition) { if (!(typeDefinition instanceof GrAnonymousClassDefinition)) return; var argumentList = ((GrAnonymousClassDefinition)typeDefinition).getArgumentListGroovy(); if (argumentList != null) { argumentList.accept(this); } final List<kotlin.Pair<ReadWriteVariableInstructi... | visitTypeDefinition |
33,877 | void (GroovyControlFlow flow) { List<kotlin.Pair<ReadWriteVariableInstruction, VariableDescriptor>> reads = ControlFlowBuilderUtil.getReadsWithoutPriorWrites(flow, false); vars.addAll(reads); } | collectVars |
33,878 | void (@NotNull GrField field) { GrExpression initializer = field.getInitializerGroovy(); if (initializer != null) { GroovyControlFlow flow = buildControlFlow(initializer); collectVars(flow); } } | visitField |
33,879 | void (@NotNull GrMethod method) { GrOpenBlock block = method.getBlock(); if (block != null) { collectVars(ControlFlowUtils.getGroovyControlFlow(block)); } } | visitMethod |
33,880 | void (@NotNull GrClassInitializer initializer) { collectVars(ControlFlowUtils.getGroovyControlFlow(initializer.getBlock())); } | visitClassInitializer |
33,881 | void (@NotNull GrVariable variable) { super.visitVariable(variable); if (myPolicy.isVariableInitialized(variable)) { ReadWriteVariableInstruction writeInst = new ReadWriteVariableInstruction(getDescriptorId(createDescriptor(variable)), variable, ReadWriteVariableInstruction.WRITE); addNodeAndCheckPending(writeInst); } ... | visitVariable |
33,882 | InstructionImpl (PsiElement element) { for (final InstructionImpl instruction : myInstructions) { if (element.equals(instruction.getElement())) return instruction; } return null; } | findInstruction |
33,883 | void (@NotNull GroovyPsiElement element) { ProgressManager.checkCanceled(); super.visitElement(element); } | visitElement |
33,884 | GrIfStatement () { return (GrIfStatement)super.getElement(); } | getElement |
33,885 | String () { return "End element: " + myPsiElement; } | getElementPresentation |
33,886 | PsiElement () { return myPsiElement; } | getElement |
33,887 | Iterable<Instruction> (@NotNull CallEnvironment environment) { final Deque<CallInstruction> stack = environment.callStack(this); for (Instruction instruction : mySuccessors) { environment.update(stack, instruction); } return mySuccessors; } | successors |
33,888 | Iterable<Instruction> (@NotNull CallEnvironment environment) { final Deque<CallInstruction> stack = environment.callStack(this); for (Instruction instruction : myPredecessors) { environment.update(stack, instruction); } return myPredecessors; } | predecessors |
33,889 | Iterable<Instruction> () { return mySuccessors; } | allSuccessors |
33,890 | Iterable<Instruction> () { return myPredecessors; } | allPredecessors |
33,891 | String () { final StringBuilder builder = new StringBuilder(); builder.append(myNumber); builder.append("("); for (Instruction successor : mySuccessors) { builder.append(successor.num()); builder.append(','); } if (!mySuccessors.isEmpty()) builder.delete(builder.length() - 1, builder.length()); builder.append(") ").app... | toString |
33,892 | String () { //return "element: " + (myPsiElement != null ? myPsiElement.getText() : null); return "element: " + myPsiElement; } | getElementPresentation |
33,893 | int () { assert myNumber != -1; return myNumber; } | num |
33,894 | void (InstructionImpl instruction) { mySuccessors.add(instruction); } | addSuccessor |
33,895 | void (InstructionImpl instruction) { myPredecessors.add(instruction); } | addPredecessor |
33,896 | void (int num) { assert myNumber == -1; myNumber = num; } | setNumber |
33,897 | boolean (@NotNull GrReferenceExpression ref) { final GrExpression qualifier = ref.getQualifier(); return (qualifier == null || isThisRef(qualifier)) && ref.resolve() instanceof GrField; } | isReferenceAccepted |
33,898 | boolean (@NotNull GrVariable variable) { return false; } | isVariableInitialized |
33,899 | GrFieldControlFlowPolicy () { return INSTANCE; } | getInstance |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.