Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
36,300 | boolean (@Nullable GrCondition condition) { if (condition == null) { return false; } return "true".equals(condition.getText()); } | isTrue |
36,301 | boolean (GrCondition condition) { if (condition == null) { return false; } return "false".equals(condition.getText()); } | isFalse |
36,302 | String (@NotNull GrExpression condition) { if (condition instanceof GrParenthesizedExpression) { final GrExpression contentExpression = ((GrParenthesizedExpression) condition).getOperand(); if (contentExpression == null) return "()"; return '(' + getNegatedExpressionText(contentExpression) + ')'; } else if (isNegation(condition)) { final GrExpression negated = getNegated(condition); return negated.getText(); } else if (ComparisonUtils.isComparison(condition)) { final GrBinaryExpression binaryExpression = (GrBinaryExpression) condition; final IElementType sign = binaryExpression.getOperationTokenType(); final String negatedComparison = ComparisonUtils.getNegatedComparison(sign); final GrExpression lhs = binaryExpression.getLeftOperand(); final GrExpression rhs = binaryExpression.getRightOperand(); assert rhs != null; return lhs.getText() + negatedComparison + rhs.getText(); } else if (ParenthesesUtils.getPrecedence(condition) > ParenthesesUtils.PREFIX_PRECEDENCE) { return "!(" + condition.getText() + ')'; } else { return '!' + condition.getText(); } } | getNegatedExpressionText |
36,303 | GrExpression (@NotNull GrExpression exp) { final GrUnaryExpression prefixExp = (GrUnaryExpression) exp; final GrExpression operand = prefixExp.getOperand(); return (GrExpression)PsiUtil.skipParentheses(operand, false); } | getNegated |
36,304 | boolean (@Nullable GrStatement statement) { if (statement == null) { return true; } if (statement instanceof GrBreakStatement || statement instanceof GrContinueStatement || statement instanceof GrReturnStatement || statement instanceof GrYieldStatement || statement instanceof GrThrowStatement) { return false; } else if (statement instanceof GrForStatement) { return forStatementMayReturnNormally((GrForStatement)statement); } else if (statement instanceof GrWhileStatement) { return whileStatementMayReturnNormally((GrWhileStatement)statement); } else if (statement instanceof GrBlockStatement) { return blockMayCompleteNormally((GrBlockStatement)statement); } else if (statement instanceof GrSynchronizedStatement syncStatement) { return openBlockMayCompleteNormally(syncStatement.getBody()); } else if (statement instanceof GrLabeledStatement) { return labeledStatementMayCompleteNormally((GrLabeledStatement)statement); } else if (statement instanceof GrIfStatement) { return ifStatementMayReturnNormally((GrIfStatement)statement); } else if (statement instanceof GrTryCatchStatement) { return tryStatementMayReturnNormally((GrTryCatchStatement)statement); } else if (statement instanceof GrSwitchStatement) { return switchStatementMayReturnNormally((GrSwitchStatement)statement); } // other statement type else { return true; } } | statementMayCompleteNormally |
36,305 | boolean (@NotNull GrWhileStatement loopStatement) { final GrCondition test = loopStatement.getCondition(); return !BoolUtils.isTrue(test) || statementIsBreakTarget(loopStatement); } | whileStatementMayReturnNormally |
36,306 | boolean (@NotNull GrForStatement loopStatement) { return true; } | forStatementMayReturnNormally |
36,307 | boolean (@NotNull GrSwitchStatement switchStatement) { if (statementIsBreakTarget(switchStatement)) { return true; } final GrCaseSection[] caseClauses = switchStatement.getCaseSections(); if (ContainerUtil.find(caseClauses, section -> section.isDefault()) == null) { return true; } final GrCaseSection lastClause = caseClauses[caseClauses.length - 1]; final GrStatement[] statements = lastClause.getStatements(); if (statements.length == 0) { return true; } return statementMayCompleteNormally(statements[statements.length - 1]); } | switchStatementMayReturnNormally |
36,308 | boolean (@NotNull GrTryCatchStatement tryStatement) { final GrFinallyClause finallyBlock = tryStatement.getFinallyClause(); if (finallyBlock != null) { if (!openBlockMayCompleteNormally(finallyBlock.getBody())) { return false; } } final GrOpenBlock tryBlock = tryStatement.getTryBlock(); if (openBlockMayCompleteNormally(tryBlock)) { return true; } for (GrCatchClause catchClause : tryStatement.getCatchClauses()) { if (openBlockMayCompleteNormally(catchClause.getBody())) { return true; } } return false; } | tryStatementMayReturnNormally |
36,309 | boolean (@NotNull GrIfStatement ifStatement) { final GrStatement thenBranch = ifStatement.getThenBranch(); if (statementMayCompleteNormally(thenBranch)) { return true; } final GrStatement elseBranch = ifStatement.getElseBranch(); return elseBranch == null || statementMayCompleteNormally(elseBranch); } | ifStatementMayReturnNormally |
36,310 | boolean (@NotNull GrLabeledStatement labeledStatement) { final GrStatement statement = labeledStatement.getStatement(); return statementMayCompleteNormally(statement) || statementIsBreakTarget(statement); } | labeledStatementMayCompleteNormally |
36,311 | boolean (@Nullable GrBlockStatement block) { if (block == null) { return true; } final GrStatement[] statements = block.getBlock().getStatements(); for (final GrStatement statement : statements) { if (!statementMayCompleteNormally(statement)) { return false; } } return true; } | blockMayCompleteNormally |
36,312 | boolean (@Nullable GrOpenBlock block) { if (block == null) { return true; } final GrStatement[] statements = block.getStatements(); for (final GrStatement statement : statements) { if (!statementMayCompleteNormally(statement)) { return false; } } return true; } | openBlockMayCompleteNormally |
36,313 | boolean (@NotNull GrStatement statement) { final BreakFinder breakFinder = new BreakFinder(statement); statement.accept(breakFinder); return breakFinder.breakFound(); } | statementIsBreakTarget |
36,314 | boolean (@NotNull GrStatement statement) { final ReturnFinder returnFinder = new ReturnFinder(); statement.accept(returnFinder); return returnFinder.returnFound(); } | statementContainsReturn |
36,315 | boolean (@NotNull GrStatement statement) { final ContinueFinder continueFinder = new ContinueFinder(statement); statement.accept(continueFinder); return continueFinder.continueFound(); } | statementIsContinueTarget |
36,316 | boolean (@NotNull GroovyPsiElement element) { return isInForStatementBody(element) || isInWhileStatementBody(element); } | isInLoop |
36,317 | boolean (@NotNull GroovyPsiElement element) { final GrFinallyClause containingClause = PsiTreeUtil.getParentOfType(element, GrFinallyClause.class); if (containingClause == null) { return false; } final GrOpenBlock body = containingClause.getBody(); return PsiTreeUtil.isAncestor(body, element, true); } | isInFinallyBlock |
36,318 | boolean (@NotNull GroovyPsiElement element) { final GrWhileStatement whileStatement = PsiTreeUtil.getParentOfType(element, GrWhileStatement.class); if (whileStatement == null) { return false; } final GrStatement body = whileStatement.getBody(); return PsiTreeUtil.isAncestor(body, element, true); } | isInWhileStatementBody |
36,319 | boolean (@NotNull GroovyPsiElement element) { final GrForStatement forStatement = PsiTreeUtil.getParentOfType(element, GrForStatement.class); if (forStatement == null) { return false; } final GrStatement body = forStatement.getBody(); return PsiTreeUtil.isAncestor(body, element, true); } | isInForStatementBody |
36,320 | GrStatement (@NotNull GrStatement branch) { if (branch instanceof GrBlockStatement block) { final GrStatement[] statements = block.getBlock().getStatements(); if (statements.length == 1) { return statements[0]; } else { return block; } } else { return branch; } } | stripBraces |
36,321 | boolean (@NotNull GrStatement containingStatement,@NotNull GrStatement statement) { GroovyPsiElement statementToCheck = statement; while (true) { if (statementToCheck.equals(containingStatement)) { return true; } final GroovyPsiElement container = getContainingStatement(statementToCheck); if (container == null) { return false; } if (container instanceof GrBlockStatement) { if (!statementIsLastInBlock((GrBlockStatement)container, (GrStatement)statementToCheck)) { return false; } } if (isLoop(container)) { return false; } statementToCheck = container; } } | statementCompletesWithStatement |
36,322 | boolean (@NotNull GrBlockStatement body, @NotNull GrStatement statement) { GrStatement statementToCheck = statement; while (true) { if (statementToCheck == null) { return false; } final PsiElement container = statementToCheck.getParent(); if (container == null) { return false; } if (container instanceof GrLoopStatement) { return false; } else if (container instanceof GrCaseSection caseSection) { if (!statementIsLastInBlock(caseSection, statementToCheck)) return false; final PsiElement parent = container.getParent(); assert parent instanceof GrSwitchStatement; final GrSwitchStatement switchStatement = (GrSwitchStatement)parent; final GrCaseSection[] sections = switchStatement.getCaseSections(); if (ArrayUtil.getLastElement(sections) != caseSection) { return false; } } else if (container instanceof GrOpenBlock block) { if (!statementIsLastInBlock(block, statementToCheck)) return false; final PsiElement parent = block.getParent(); if (parent instanceof GrBlockStatement blockStatement) { if (blockStatement == body) return true; } } else if (container instanceof GrClosableBlock) { return false; } statementToCheck = getContainingStatement(statementToCheck); } } | blockCompletesWithStatement |
36,323 | boolean (@NotNull GrCodeBlock body, @NotNull GrStatement statement) { GroovyPsiElement elementToCheck = statement; while (true) { if (elementToCheck == null) return false; final GroovyPsiElement container = PsiTreeUtil.getParentOfType(elementToCheck, GrStatement.class, GrCodeBlock.class, GrCaseSection.class); if (container == null) return false; if (isLoop(container)) return false; if (container instanceof GrCaseSection) { final GrSwitchStatement switchStatement = (GrSwitchStatement)container.getParent(); final GrCaseSection[] sections = switchStatement.getCaseSections(); if (container == sections[sections.length - 1]) return false; } if (container instanceof GrCodeBlock) { if (elementToCheck instanceof GrStatement) { final GrCodeBlock codeBlock = (GrCodeBlock)container; if (!statementIsLastInBlock(codeBlock, (GrStatement)elementToCheck)) { return false; } } if (container instanceof GrOpenBlock || container instanceof GrClosableBlock) { if (container.equals(body)) { return true; } elementToCheck = PsiTreeUtil.getParentOfType(container, GrStatement.class); } else { elementToCheck = container; } } else { elementToCheck = container; } } } | openBlockCompletesWithStatement |
36,324 | boolean (@NotNull GrClosableBlock body,@NotNull GrStatement statement) { GroovyPsiElement statementToCheck = statement; while (true) { if (!(statementToCheck instanceof GrExpression || statementToCheck instanceof GrReturnStatement)) { return false; } final GroovyPsiElement container = getContainingStatementOrBlock(statementToCheck); if (container == null) { return false; } if (isLoop(container)) { return false; } if (container instanceof GrCodeBlock) { if (!statementIsLastInBlock((GrCodeBlock)container, (GrStatement)statementToCheck)) { return false; } if (container.equals(body)) { return true; } statementToCheck = PsiTreeUtil.getParentOfType(container, GrStatement.class); } else { statementToCheck = container; } } } | closureCompletesWithStatement |
36,325 | boolean (@NotNull PsiElement element) { return element instanceof GrLoopStatement; } | isLoop |
36,326 | GrStatement (@NotNull GroovyPsiElement statement) { return PsiTreeUtil.getParentOfType(statement, GrStatement.class); } | getContainingStatement |
36,327 | GroovyPsiElement (@NotNull GroovyPsiElement statement) { return PsiTreeUtil.getParentOfType(statement, GrStatement.class, GrCodeBlock.class); } | getContainingStatementOrBlock |
36,328 | boolean (@NotNull GrBlockStatement block, @NotNull GrStatement statement) { return statementIsLastInBlock(block.getBlock(), statement); } | statementIsLastInBlock |
36,329 | boolean (@NotNull GrStatementOwner block, @NotNull GrStatement statement) { GrStatement lastStatement = ArrayUtil.getLastElement(block.getStatements()); return statement == lastStatement; } | statementIsLastInBlock |
36,330 | List<GrStatement> (@Nullable GroovyPsiElement element) { return collectReturns(element, element instanceof GrCodeBlock || element instanceof GroovyFile || element instanceof GrLambdaBody); } | collectReturns |
36,331 | List<GrStatement> (@Nullable GroovyPsiElement element, final boolean allExitPoints) { if (element == null) return Collections.emptyList(); final GroovyControlFlow flow; if (element instanceof GrControlFlowOwner) { flow = getGroovyControlFlow((GrControlFlowOwner)element); } else { flow = ControlFlowBuilder.buildControlFlow(element); } return collectReturns(flow.getFlow(), element, allExitPoints); } | collectReturns |
36,332 | boolean (Instruction instruction, @Nullable GrExpression returnValue) { final PsiElement element = instruction.getElement(); if ((statementFilter != null && statementFilter.isInstance(element)) || (instructionFilter != null && instructionFilter.isInstance(instruction))) { collector.add((GrStatement)element); } return true; } | visitExitPoint |
36,333 | List<GrStatement> () { return collector; } | getCollectedStatements |
36,334 | List<GrStatement> (Instruction @NotNull [] flow, @NotNull GroovyPsiElement element, final boolean allExitPoints) { boolean[] visited = new boolean[flow.length]; var collector = new ExitPointCollector(allExitPoints ? MaybeReturnInstruction.class : null, GrReturnStatement.class); visitAllExitPointsInner(flow[flow.length - 1], flow[0], visited, collector); return collector.getCollectedStatements(); } | collectReturns |
36,335 | List<GrStatement> (Instruction @NotNull [] flow) { boolean[] visited = new boolean[flow.length]; var collector = new ExitPointCollector(MaybeYieldInstruction.class, GrYieldStatement.class); visitAllExitPointsInner(flow[flow.length - 1], flow[0], visited, collector); return collector.getCollectedStatements(); } | collectYields |
36,336 | GrExpression (GrStatement returnStatement) { if (returnStatement instanceof GrReturnStatement) return ((GrReturnStatement)returnStatement).getReturnValue(); if (returnStatement instanceof GrExpression) return (GrExpression)returnStatement; return null; } | extractReturnExpression |
36,337 | boolean (GrReferenceExpression referenceExpression) { final PsiElement parent = referenceExpression.getParent(); if (parent instanceof GrUnaryExpression) { final IElementType opType = ((GrUnaryExpression)parent).getOperationTokenType(); return opType == GroovyTokenTypes.mDEC || opType == GroovyTokenTypes.mINC; } return false; } | isIncOrDecOperand |
36,338 | String (GroovyControlFlow flow) { StringBuilder builder = new StringBuilder(); for (Instruction instruction : flow.getFlow()) { String repr; if (instruction instanceof ReadWriteVariableInstruction) { int descriptorId = ((ReadWriteVariableInstruction)instruction).getDescriptor(); repr = instruction.toString().replace(" " + descriptorId, " " + flow.getVarIndices()[descriptorId].getName()); } else { repr = instruction.toString(); } builder.append(repr).append("\n"); } return builder.toString(); } | dumpControlFlow |
36,339 | ReadWriteVariableInstruction (final GrReferenceExpression refExpr, final Instruction[] flow) { for (Instruction instruction : flow) { if (instruction instanceof ReadWriteVariableInstruction && instruction.getElement() == refExpr) { return (ReadWriteVariableInstruction)instruction; } } return null; } | findRWInstruction |
36,340 | Instruction (PsiElement place, Instruction[] flow) { List<Instruction> applicable = new ArrayList<>(); for (Instruction instruction : flow) { final PsiElement element = instruction.getElement(); if (element == null) continue; if (element == place) return instruction; if (PsiTreeUtil.isAncestor(element, place, true)) { applicable.add(instruction); } } if (applicable.isEmpty()) return null; applicable.sort((o1, o2) -> { PsiElement e1 = o1.getElement(); PsiElement e2 = o2.getElement(); LOG.assertTrue(e1 != null); LOG.assertTrue(e2 != null); final TextRange t1 = e1.getTextRange(); final TextRange t2 = e2.getTextRange(); final int s1 = t1.getStartOffset(); final int s2 = t2.getStartOffset(); if (s1 == s2) { return t1.getEndOffset() - t2.getEndOffset(); } return s2 - s1; }); return applicable.get(0); } | findNearestInstruction |
36,341 | boolean (@NotNull GrExpression expression) { GrControlFlowOwner flowOwner = findControlFlowOwner(expression); return flowOwner != null && PsiUtil.isExpressionStatement(expression) && isReturnValue(expression, flowOwner) && !PsiUtil.isVoidMethodCall(expression); } | isImplicitReturnStatement |
36,342 | boolean () { return m_found; } | returnFound |
36,343 | void (@NotNull GrReturnStatement returnStatement) { if (m_found) { return; } super.visitReturnStatement(returnStatement); m_found = true; } | visitReturnStatement |
36,344 | boolean () { return m_found; } | breakFound |
36,345 | void (@NotNull GrBreakStatement breakStatement) { if (m_found) { return; } super.visitBreakStatement(breakStatement); final GrStatement exitedStatement = breakStatement.findTargetStatement(); if (exitedStatement == null) { return; } if (PsiTreeUtil.isAncestor(exitedStatement, m_target, false)) { m_found = true; } } | visitBreakStatement |
36,346 | boolean () { return m_found; } | continueFound |
36,347 | void (@NotNull GrContinueStatement continueStatement) { if (m_found) { return; } super.visitContinueStatement(continueStatement); final GrStatement exitedStatement = continueStatement.findTargetStatement(); if (exitedStatement == null) { return; } if (PsiTreeUtil.isAncestor(exitedStatement, m_target, false)) { m_found = true; } } | visitContinueStatement |
36,348 | Set<GrExpression> (@NotNull final GrControlFlowOwner block) { return CachedValuesManager.getCachedValue(block, () -> { final Set<GrExpression> result = new HashSet<>(); visitAllExitPoints(block, new ExitPointVisitor() { @Override public boolean visitExitPoint(Instruction instruction, @Nullable GrExpression returnValue) { ContainerUtil.addIfNotNull(result, returnValue); return true; } }); return CachedValueProvider.Result.create(result, block); }); } | getAllReturnValues |
36,349 | boolean (Instruction instruction, @Nullable GrExpression returnValue) { ContainerUtil.addIfNotNull(result, returnValue); return true; } | visitExitPoint |
36,350 | boolean (@NotNull GrExpression expression, @NotNull GrControlFlowOwner flowOwner) { return getAllReturnValues(flowOwner).contains(expression); } | isReturnValue |
36,351 | boolean (@Nullable GrControlFlowOwner block, ExitPointVisitor visitor) { if (block == null) return true; final Instruction[] flow = block.getControlFlow(); boolean[] visited = new boolean[flow.length]; return visitAllExitPointsInner(flow[flow.length - 1], flow[0], visited, visitor); } | visitAllExitPoints |
36,352 | boolean (Instruction last, Instruction first, boolean[] visited, ExitPointVisitor visitor) { if (first == last) return true; var shift = first.num(); if (last instanceof AfterCallInstruction) { visited[last.num() - shift] = true; return visitAllExitPointsInner(((AfterCallInstruction)last).myCall, first, visited, visitor); } if (last instanceof MaybeInterruptInstruction) { return visitor.visitExitPoint(last, (GrExpression)last.getElement()); } else if (last instanceof IfEndInstruction) { visited[last.num() - shift] = true; for (Instruction instruction : last.allPredecessors()) { if (!visitAllExitPointsInner(instruction, first, visited, visitor)) return false; } return true; } else if (last instanceof ThrowingInstruction) { PsiElement element = last.getElement(); if (!(element instanceof GrThrowStatement || element instanceof GrAssertStatement)) return true; } PsiElement element = last.getElement(); if (element != null) { final GrExpression returnValue; if (element instanceof GrReturnStatement) { returnValue = ((GrReturnStatement)element).getReturnValue(); } else if (element instanceof GrExpression && PsiUtil.isExpressionStatement(element)) { returnValue = (GrExpression)element; } else { returnValue = null; } return visitor.visitExitPoint(last, returnValue); } visited[last.num() - shift] = true; for (Instruction pred : last.allPredecessors()) { if (!visited[pred.num() - shift]) { if (!visitAllExitPointsInner(pred, first, visited, visitor)) return false; } } return true; } | visitAllExitPointsInner |
36,353 | GrControlFlowOwner (PsiElement place) { place = place.getContext(); while (place != null) { if (place instanceof GrControlFlowOwner && ((GrControlFlowOwner)place).isTopControlFlowOwner()) return (GrControlFlowOwner)place; if (place instanceof GrMethod) return ((GrMethod)place).getBlock(); if (place instanceof GrClassInitializer) return ((GrClassInitializer)place).getBlock(); place = place.getContext(); } return null; } | findControlFlowOwner |
36,354 | List<ReadWriteVariableInstruction> (GrVariable local, final PsiElement place, boolean ahead, boolean writeAccessOnly) { LOG.assertTrue(!(local instanceof GrField), local.getClass()); final GrControlFlowOwner owner = findControlFlowOwner(place); assert owner != null; GroovyControlFlow flow = getGroovyControlFlow(owner); final Instruction cur = findInstruction(place, flow.getFlow()); if (cur == null) { throw new IllegalArgumentException("place is not in the flow"); } return findAccess(flow.getIndex(createDescriptor(local)), ahead, writeAccessOnly, cur); } | findAccess |
36,355 | List<ReadWriteVariableInstruction> (int variableIndex, boolean ahead, boolean writeAccessOnly, Instruction cur) { if (variableIndex == 0) { return Collections.emptyList(); } final ArrayList<ReadWriteVariableInstruction> result = new ArrayList<>(); final HashSet<Instruction> visited = new HashSet<>(); visited.add(cur); Queue<Instruction> queue = new ArrayDeque<>(); for (Instruction i : ahead ? cur.allSuccessors() : cur.allPredecessors()) { if (visited.add(i)) { queue.add(i); } } while (true) { Instruction instruction = queue.poll(); if (instruction == null) break; if (instruction instanceof ReadWriteVariableInstruction rw) { if (variableIndex == rw.getDescriptor()) { if (rw.isWrite()) { result.add(rw); continue; } if (!writeAccessOnly) { result.add(rw); } } } for (Instruction i : ahead ? instruction.allSuccessors() : instruction.allPredecessors()) { if (visited.add(i)) { queue.add(i); } } } return result; } | findAccess |
36,356 | Instruction (final PsiElement place, Instruction[] controlFlow) { return ContainerUtil.find(controlFlow, instruction -> instruction.getElement() == place); } | findInstruction |
36,357 | BitSet (@NotNull List<? extends BitSet> ins) { if (ins.size() == 0) { return neutral; } if (ins.size() == 1) { return ins.get(0); } BitSet result = new BitSet(groovyFlow.getFlow().length); for (BitSet set : ins) { result.or(set); } return result; } | join |
36,358 | BitSet (@NotNull BitSet bitSet, @NotNull Instruction instruction) { if (!(instruction instanceof ReadWriteVariableInstruction)) return bitSet; if (!((ReadWriteVariableInstruction)instruction).isWrite()) return bitSet; final PsiElement element = instruction.getElement(); if (element instanceof GrVariable && element != var) return bitSet; if (element instanceof GrReferenceExpression ref) { if (ref.isQualified() || ref.resolve() != var) { return bitSet; } } if (!groovyFlow.getVarIndices()[((ReadWriteVariableInstruction)instruction).getDescriptor()].equals(createDescriptor(var))) { return bitSet; } BitSet newResult = new BitSet(groovyFlow.getFlow().length); newResult.set(instruction.num()); return newResult; } | fun |
36,359 | GroovyControlFlow (@NotNull GrControlFlowOwner owner) { if (owner instanceof GroovyFileBaseImpl) { return ((GroovyFileBaseImpl)owner).getGroovyControlFlow(); } else if (owner instanceof GrExpressionLambdaBody) { return ControlFlowBuilder.buildControlFlow(owner); } else if (owner instanceof GrBlockImpl) { return ((GrBlockImpl)owner).getGroovyControlFlow(); } else { LOG.error("Unrecognized control flow owner"); throw new IllegalStateException(); } } | getGroovyControlFlow |
36,360 | boolean (@NotNull GrExpression exp) { final SideEffectsVisitor visitor = new SideEffectsVisitor(); exp.accept(visitor); return visitor.mayHaveSideEffects(); } | mayHaveSideEffects |
36,361 | void (@NotNull GroovyPsiElement element) { if (!mayHaveSideEffects) { super.visitElement(element); } } | visitElement |
36,362 | void (@NotNull GrAssignmentExpression expression) { if (mayHaveSideEffects) { return; } super.visitAssignmentExpression(expression); mayHaveSideEffects = true; } | visitAssignmentExpression |
36,363 | void (@NotNull GrMethodCallExpression expression) { if (mayHaveSideEffects) { return; } super.visitMethodCallExpression(expression); mayHaveSideEffects = true; } | visitMethodCallExpression |
36,364 | void (@NotNull GrNewExpression expression) { if (mayHaveSideEffects) { return; } super.visitNewExpression(expression); mayHaveSideEffects = true; } | visitNewExpression |
36,365 | void (@NotNull GrUnaryExpression expression) { if (mayHaveSideEffects) { return; } super.visitUnaryExpression(expression); final IElementType tokenType = expression.getOperationTokenType(); if (tokenType.equals(GroovyTokenTypes.mINC) || tokenType.equals(GroovyTokenTypes.mDEC)) { mayHaveSideEffects = true; } } | visitUnaryExpression |
36,366 | boolean () { return mayHaveSideEffects; } | mayHaveSideEffects |
36,367 | boolean (@NotNull PsiClass aClass) { return aClass instanceof PsiCompiledElement; } | classIsInLibrary |
36,368 | boolean ( @NotNull GrMethodCallExpression expression) { final PsiMethod method = expression.resolveMethod(); return method instanceof PsiCompiledElement; } | callOnLibraryMethod |
36,369 | boolean (PsiMethod method) { final PsiMethod[] superMethods = method.findSuperMethods(); for (PsiMethod superMethod : superMethods) { final PsiClass containingClass = superMethod.getContainingClass(); if (containingClass != null && classIsInLibrary(containingClass)) { return true; } if (isOverrideOfLibraryMethod(superMethod)) { return true; } } return false; } | isOverrideOfLibraryMethod |
36,370 | boolean ( PsiVariable variable) { if (variable instanceof PsiParameter parameter) { final PsiElement scope = parameter.getDeclarationScope(); if (scope instanceof PsiMethod method) { if (isOverrideOfLibraryMethod(method)) { return true; } } } return false; } | isOverrideOfLibraryMethodParameter |
36,371 | boolean (@Nullable GrStatement exp1, @Nullable GrStatement exp2) { if (exp1 == null && exp2 == null) { return true; } if (exp1 == null || exp2 == null) { return false; } final int type1 = getStatementType(exp1); final int type2 = getStatementType(exp2); if (type1 != type2) { return false; } return switch (type1) { case BLOCK_STATEMENT -> blockStatementsAreEquivalent((GrBlockStatement)exp1, (GrBlockStatement)exp2); case BREAK_STATEMENT, CONTINUE_STATEMENT, EMPTY_STATEMENT -> true; case VAR_STATEMENT -> varStatementsAreEquivalent((GrVariableDeclaration)exp1, (GrVariableDeclaration)exp2); case APPLICATION_STATEMENT -> applicationStatementsAreEquivalent((GrApplicationStatement)exp1, (GrApplicationStatement)exp2); case EXPRESSION_STATEMENT -> expressionStatementsAreEquivalent((GrExpression)exp1, (GrExpression)exp2); case FOR_STATEMENT -> forInStatementsAreEquivalent((GrForStatement)exp1, (GrForStatement)exp2); case IF_STATEMENT -> ifStatementsAreEquivalent((GrIfStatement)exp1, (GrIfStatement)exp2); case RETURN_STATEMENT -> returnStatementsAreEquivalent((GrReturnStatement)exp1, (GrReturnStatement)exp2); case SWITCH_STATEMENT -> switchStatementsAreEquivalent((GrSwitchStatement)exp1, (GrSwitchStatement)exp2); case THROW_STATEMENT -> throwStatementsAreEquivalent((GrThrowStatement)exp1, (GrThrowStatement)exp2); case TRY_STATEMENT -> tryStatementsAreEquivalent((GrTryCatchStatement)exp1, (GrTryCatchStatement)exp2); case WHILE_STATEMENT -> whileStatementsAreEquivalent((GrWhileStatement)exp1, (GrWhileStatement)exp2); case SYNCHRONIZED_STATEMENT -> synchronizedStatementsAreEquivalent((GrSynchronizedStatement)exp1, (GrSynchronizedStatement)exp2); case ASSERT_STATEMENT -> assertStatementsAreEquivalent((GrAssertStatement)exp1, (GrAssertStatement)exp2); default -> false; }; } | statementsAreEquivalent |
36,372 | boolean (GrApplicationStatement statement1, GrApplicationStatement statement2) { final GrExpression funExpression1 = statement1.getInvokedExpression(); final GrExpression funExpression2 = statement2.getInvokedExpression(); if (!expressionsAreEquivalent(funExpression1, funExpression2)) { return false; } final GrArgumentList argumentList1 = statement1.getArgumentList(); final GrArgumentList argumentList2 = statement2.getArgumentList(); final GrExpression[] args1 = argumentList1.getExpressionArguments(); final GrExpression[] args2 = argumentList2.getExpressionArguments(); if (!expressionListsAreEquivalent(args1, args2)) { return false; } final GrNamedArgument[] namedArgs1 = argumentList1.getNamedArguments(); final GrNamedArgument[] namedArgs2 = argumentList2.getNamedArguments(); if (!namedArgumentListsAreEquivalent(namedArgs1, namedArgs2)) { return false; } return true; } | applicationStatementsAreEquivalent |
36,373 | boolean (GrAssertStatement statement1, GrAssertStatement statement2) { return expressionsAreEquivalent(statement1.getAssertion(), statement2.getAssertion()) && expressionsAreEquivalent(statement1.getErrorMessage(), statement2.getErrorMessage()); } | assertStatementsAreEquivalent |
36,374 | boolean (GrSynchronizedStatement statement1, GrSynchronizedStatement statement2) { return expressionsAreEquivalent(statement1.getMonitor(), statement2.getMonitor()) && openBlocksAreEquivalent(statement1.getBody(), statement2.getBody()); } | synchronizedStatementsAreEquivalent |
36,375 | boolean (@NotNull GrVariableDeclaration statement1, @NotNull GrVariableDeclaration statement2) { final GrVariable[] variables1 = statement1.getVariables(); final GrVariable[] variables2 = statement2.getVariables(); return ArrayUtil.areEqual(variables1, variables2, (v1, v2) -> variablesAreEquivalent(v1, v2)); } | varStatementsAreEquivalent |
36,376 | boolean (@NotNull GrVariable var1, @NotNull GrVariable var2) { final GrExpression initializer1 = var1.getInitializerGroovy(); final GrExpression initializer2 = var2.getInitializerGroovy(); if (!expressionsAreEquivalent(initializer1, initializer2)) { return false; } final PsiType type1 = var1.getType(); final PsiType type2 = var2.getType(); if (!typesAreEquivalent(type1, type2)) { return false; } final String name1 = var1.getName(); final String name2 = var2.getName(); return name1.equals(name2); } | variablesAreEquivalent |
36,377 | boolean (@NotNull GrTryCatchStatement statement1, @NotNull GrTryCatchStatement statement2) { final GrOpenBlock tryBlock1 = statement1.getTryBlock(); final GrOpenBlock tryBlock2 = statement2.getTryBlock(); if (!openBlocksAreEquivalent(tryBlock1, tryBlock2)) { return false; } final GrFinallyClause finallyBlock1 = statement1.getFinallyClause(); final GrFinallyClause finallyBlock2 = statement2.getFinallyClause(); if (finallyBlock1 != null) { if (finallyBlock2 == null || !openBlocksAreEquivalent(finallyBlock1.getBody(), finallyBlock2.getBody())) { return false; } } else if (finallyBlock2 != null) { return false; } final GrCatchClause[] catchBlocks1 = statement1.getCatchClauses(); final GrCatchClause[] catchBlocks2 = statement2.getCatchClauses(); return ArrayUtil.areEqual(catchBlocks1, catchBlocks2, (c1, c2) -> catchClausesAreEquivalent(c1, c2)); } | tryStatementsAreEquivalent |
36,378 | boolean (GrCatchClause clause1, GrCatchClause clause2) { return parametersAreEquivalent(clause1.getParameter(), clause2.getParameter()) && openBlocksAreEquivalent(clause1.getBody(), clause2.getBody()); } | catchClausesAreEquivalent |
36,379 | boolean (@Nullable GrParameter parameter1, @Nullable GrParameter parameter2) { if (parameter1 == null || parameter2 == null) { return false; } final PsiType type1 = parameter1.getType(); final PsiType type2 = parameter2.getType(); if (!typesAreEquivalent(type1, type2)) { return false; } final String name1 = parameter1.getName(); final String name2 = parameter2.getName(); return name1.equals(name2); } | parametersAreEquivalent |
36,380 | boolean (@Nullable PsiType type1, @Nullable PsiType type2) { return Objects.equals(type1, type2); } | typesAreEquivalent |
36,381 | boolean (@NotNull GrWhileStatement statement1, @NotNull GrWhileStatement statement2) { final GrExpression condition1 = statement1.getCondition(); final GrExpression condition2 = statement2.getCondition(); final GrStatement body1 = statement1.getBody(); final GrStatement body2 = statement2.getBody(); return expressionsAreEquivalent(condition1, condition2) && statementsAreEquivalent(body1, body2); } | whileStatementsAreEquivalent |
36,382 | boolean (@NotNull GrForStatement statement1, @NotNull GrForStatement statement2) { final GrForClause clause1 = statement1.getClause(); final GrForClause clause2 = statement2.getClause(); if (!forClausesAreEquivalent(clause1, clause2)) { return false; } final GrStatement body1 = statement1.getBody(); final GrStatement body2 = statement2.getBody(); return statementsAreEquivalent(body1, body2); } | forInStatementsAreEquivalent |
36,383 | boolean (@Nullable GrForClause statement1, @Nullable GrForClause statement2) { if (statement1 == null && statement2 == null) return true; if (statement1 == null || statement2 == null) return false; GrVariable[] variables1 = statement1.getDeclaredVariables(); GrVariable[] variables2 = statement2.getDeclaredVariables(); return ArrayUtil.areEqual(variables1, variables2, (var1, var2) -> (var1 == null && var2 == null) || (var1 != null && var2 != null && variablesAreEquivalent(var1, var2))); } | forClausesAreEquivalent |
36,384 | boolean (@NotNull GrSwitchStatement statement1, @NotNull GrSwitchStatement statement2) { final GrExpression switchExpression1 = statement1.getCondition(); final GrExpression switchExpression2 = statement2.getCondition(); if (!expressionsAreEquivalent(switchExpression1, switchExpression2)) { return false; } final GrCaseSection[] clauses1 = statement1.getCaseSections(); final GrCaseSection[] clauses2 = statement2.getCaseSections(); return ArrayUtil.areEqual(clauses1, clauses2, (c1, c2) -> caseClausesAreEquivalent(c1, c2)); } | switchStatementsAreEquivalent |
36,385 | boolean (GrCaseSection clause1, GrCaseSection clause2) { return ArrayUtil.areEqual(clause1.getExpressions(), clause2.getExpressions(), (l1, l2) -> expressionsAreEquivalent(l1, l2)) && ArrayUtil.areEqual(clause1.getStatements(), clause2.getStatements(), (s1, s2) -> statementsAreEquivalent(s1, s2)); } | caseClausesAreEquivalent |
36,386 | boolean (@NotNull GrBlockStatement statement1, @NotNull GrBlockStatement statement2) { final GrOpenBlock block1 = statement1.getBlock(); final GrOpenBlock block2 = statement2.getBlock(); return openBlocksAreEquivalent(block1, block2); } | blockStatementsAreEquivalent |
36,387 | boolean (@Nullable GrOpenBlock block1, @Nullable GrOpenBlock block2) { if (block1 == null || block2 == null) return false; return ArrayUtil.areEqual(block1.getStatements(), block2.getStatements(), (s1, s2) -> statementsAreEquivalent(s1, s2)); } | openBlocksAreEquivalent |
36,388 | boolean (@NotNull GrIfStatement statement1, @NotNull GrIfStatement statement2) { final GrExpression condition1 = statement1.getCondition(); final GrExpression condition2 = statement2.getCondition(); final GrStatement thenBranch1 = statement1.getThenBranch(); final GrStatement thenBranch2 = statement2.getThenBranch(); final GrStatement elseBranch1 = statement1.getElseBranch(); final GrStatement elseBranch2 = statement2.getElseBranch(); return expressionsAreEquivalent(condition1, condition2) && statementsAreEquivalent(thenBranch1, thenBranch2) && statementsAreEquivalent(elseBranch1, elseBranch2); } | ifStatementsAreEquivalent |
36,389 | boolean (@NotNull GrExpression statement1, @NotNull GrExpression statement2) { return expressionsAreEquivalent(statement1, statement2); } | expressionStatementsAreEquivalent |
36,390 | boolean (@NotNull GrReturnStatement statement1, @NotNull GrReturnStatement statement2) { final GrExpression returnValue1 = statement1.getReturnValue(); final GrExpression returnValue2 = statement2.getReturnValue(); return expressionsAreEquivalent(returnValue1, returnValue2); } | returnStatementsAreEquivalent |
36,391 | boolean (@NotNull GrThrowStatement statement1, @NotNull GrThrowStatement statement2) { final GrExpression exception1 = statement1.getException(); final GrExpression exception2 = statement2.getException(); return expressionsAreEquivalent(exception1, exception2); } | throwStatementsAreEquivalent |
36,392 | boolean (@Nullable GrExpression exp1, @Nullable GrExpression exp2) { if (exp1 == null && exp2 == null) { return true; } if (exp1 == null || exp2 == null) { return false; } GrExpression expToCompare1 = (GrExpression)PsiUtil.skipParentheses(exp1, false); GrExpression expToCompare2 = (GrExpression)PsiUtil.skipParentheses(exp2, false); final int type1 = getExpressionType(expToCompare1); final int type2 = getExpressionType(expToCompare2); if (type1 != type2) { return false; } return switch (type1) { case LITERAL_EXPRESSION, REFERENCE_EXPRESSION -> { final String text1 = expToCompare1.getText(); final String text2 = expToCompare2.getText(); yield text1.equals(text2); } case CALL_EXPRESSION -> methodCallExpressionsAreEquivalent((GrMethodCall)expToCompare1, (GrMethodCall)expToCompare2); case NEW_EXPRESSION -> newExpressionsAreEquivalent((GrNewExpression)expToCompare1, (GrNewExpression)expToCompare2); case PREFIX_EXPRESSION -> prefixExpressionsAreEquivalent((GrUnaryExpression)expToCompare1, (GrUnaryExpression)expToCompare2); case POSTFIX_EXPRESSION -> postfixExpressionsAreEquivalent((GrUnaryExpression)expToCompare1, (GrUnaryExpression)expToCompare2); case BINARY_EXPRESSION -> binaryExpressionsAreEquivalent((GrBinaryExpression)expToCompare1, (GrBinaryExpression)expToCompare2); case ASSIGNMENT_EXPRESSION -> assignmentExpressionsAreEquivalent((GrAssignmentExpression)expToCompare1, (GrAssignmentExpression)expToCompare2); case CONDITIONAL_EXPRESSION -> conditionalExpressionsAreEquivalent((GrConditionalExpression)expToCompare1, (GrConditionalExpression)expToCompare2); case ELVIS_EXPRESSION -> elvisExpressionsAreEquivalent((GrElvisExpression)expToCompare1, (GrElvisExpression)expToCompare2); case RANGE_EXPRESSION -> rangeExpressionsAreEquivalent((GrRangeExpression)expToCompare1, (GrRangeExpression)expToCompare2); case TYPE_CAST_EXPRESSION -> typecastExpressionsAreEquivalent((GrTypeCastExpression)expToCompare1, (GrTypeCastExpression)expToCompare2); case SAFE_CAST_EXPRESSION -> safeCastExpressionsAreEquivalent((GrSafeCastExpression)expToCompare1, (GrSafeCastExpression)expToCompare2); case INSTANCEOF_EXPRESSION -> instanceofExpressionsAreEquivalent((GrInstanceOfExpression)expToCompare1, (GrInstanceOfExpression)expToCompare2); case INDEX_EXPRESSION -> indexExpressionsAreEquivalent((GrIndexProperty)expToCompare1, (GrIndexProperty)expToCompare2); case LIST_OR_MAP_EXPRESSION -> listOrMapExpressionsAreEquivalent((GrListOrMap)expToCompare1, (GrListOrMap)expToCompare2); case CLOSABLE_BLOCK_EXPRESSION -> closableBlockExpressionsAreEquivalent((GrClosableBlock)expToCompare1, (GrClosableBlock)expToCompare2); case PROPERTY_SELECTION_EXPRESSION -> // todo textOfExpressionsIsEquivalent(expToCompare1, expToCompare2); default -> false; }; } | expressionsAreEquivalent |
36,393 | boolean (GrExpression expToCompare1, GrExpression expToCompare2) { final String text1 = expToCompare1.getText(); final String text2 = expToCompare2.getText(); return text1.equals(text2); } | textOfExpressionsIsEquivalent |
36,394 | boolean (GrClosableBlock closableBlock1, GrClosableBlock closableBlock2) { return ArrayUtil.areEqual(closableBlock1.getStatements(), closableBlock2.getStatements(), (s1, s2) -> statementsAreEquivalent(s1, s2)) && ArrayUtil.areEqual(closableBlock1.getParameters(), closableBlock2.getParameters(), (p1, p2) -> parametersAreEquivalent(p1, p2)); } | closableBlockExpressionsAreEquivalent |
36,395 | boolean (GrListOrMap expression1, GrListOrMap expression2) { return expression1.isMap() == expression2.isMap() && expressionListsAreEquivalent(expression1.getInitializers(), expression2.getInitializers()) && namedArgumentListsAreEquivalent(expression1.getNamedArguments(), expression2.getNamedArguments()); } | listOrMapExpressionsAreEquivalent |
36,396 | boolean (GrArrayDeclaration declaration1, GrArrayDeclaration declaration2) { final int count1 = declaration1.getArrayCount(); final int count2 = declaration2.getArrayCount(); if (count1 != count2) { return false; } final GrExpression[] bounds1 = declaration1.getBoundExpressions(); final GrExpression[] bounds2 = declaration2.getBoundExpressions(); return expressionListsAreEquivalent(bounds1, bounds2); } | arrayDeclarationsAreEquivalent |
36,397 | boolean (GrInstanceOfExpression expression1, GrInstanceOfExpression expression2) { final GrExpression operand1 = expression1.getOperand(); final GrExpression operand2 = expression2.getOperand(); if (!expressionsAreEquivalent(operand1, operand2)) { return false; } GrTypeElement typeElement1 = expression1.getTypeElement(); GrTypeElement typeElement2 = expression2.getTypeElement(); if (typeElement1 == null || typeElement2 == null) return false; final PsiType type1 = typeElement1.getType(); final PsiType type2 = typeElement2.getType(); return typesAreEquivalent(type1, type2); } | instanceofExpressionsAreEquivalent |
36,398 | boolean (GrIndexProperty expression1, GrIndexProperty expression2) { return expressionsAreEquivalent(expression1.getInvokedExpression(), expression2.getInvokedExpression()) && argumentListsAreEquivalent(expression1.getArgumentList(), expression2.getArgumentList()); } | indexExpressionsAreEquivalent |
36,399 | boolean (GrTypeCastExpression expression1, GrTypeCastExpression expression2) { final GrExpression operand1 = expression1.getOperand(); final GrExpression operand2 = expression2.getOperand(); if (!expressionsAreEquivalent(operand1, operand2)) { return false; } final PsiType type1 = expression1.getCastTypeElement().getType(); final PsiType type2 = expression2.getCastTypeElement().getType(); return typesAreEquivalent(type1, type2); } | typecastExpressionsAreEquivalent |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.