Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
36,900
String () { return "m_[a-z][A-Za-z\\d]*"; }
getDefaultRegex
36,901
int () { return DEFAULT_MIN_LENGTH; }
getDefaultMinLength
36,902
int () { return DEFAULT_MAX_LENGTH; }
getDefaultMaxLength
36,903
BaseInspectionVisitor () { return new NamingConventionsVisitor(); }
buildVisitor
36,904
void (@NotNull GrField grField) { super.visitField(grField); if (grField.hasModifierProperty(PsiModifier.STATIC)) { return; } final String name = grField.getName(); if (isValid(name)) { return; } registerVariableError(grField, name); }
visitField
36,905
GroovyFix (@NotNull PsiElement location) { return GroovyQuickFixFactory.getInstance().createRenameFix(); }
buildFix
36,906
boolean () { return true; }
buildQuickFixesOnlyForOnTheFlyErrors
36,907
String (Object... args) { final String className = (String) args[0]; if (className.length() < getMinLength()) { return GroovyBundle.message("inspection.message.static.variable.name.ref.too.short"); } else if (className.length() > getMaxLength()) { return GroovyBundle.message("inspection.message.static.variable.name.ref.too.long"); } return GroovyBundle.message("inspection.message.static.variable.name.ref.doesnt.match.regex", getRegex()); }
buildErrorString
36,908
String () { return "s_[a-z][A-Za-z\\d]*"; }
getDefaultRegex
36,909
int () { return DEFAULT_MIN_LENGTH; }
getDefaultMinLength
36,910
int () { return DEFAULT_MAX_LENGTH; }
getDefaultMaxLength
36,911
BaseInspectionVisitor () { return new NamingConventionsVisitor(); }
buildVisitor
36,912
void (@NotNull GrField grField) { super.visitField(grField); if (!grField.hasModifierProperty(PsiModifier.STATIC)) { return; } if (grField.hasModifierProperty(PsiModifier.FINAL)) { return; } final String name = grField.getName(); if (isValid(name)) { return; } registerVariableError(grField, name); }
visitField
36,913
GroovyFix (@NotNull PsiElement location) { return GroovyQuickFixFactory.getInstance().createRenameFix(); }
buildFix
36,914
boolean () { return true; }
buildQuickFixesOnlyForOnTheFlyErrors
36,915
String (Object... args) { final String className = (String) args[0]; if (className.length() < getMinLength()) { return GroovyBundle.message("inspection.message.constant.name.ref.too.short"); } else if (className.length() > getMaxLength()) { return GroovyBundle.message("inspection.message.constant.name.ref.too.long"); } return GroovyBundle.message("inspection.message.constant.name.ref.doesnt.match.regex", getRegex()); }
buildErrorString
36,916
String () { return "[A-Z\\d]*"; }
getDefaultRegex
36,917
int () { return DEFAULT_MIN_LENGTH; }
getDefaultMinLength
36,918
int () { return DEFAULT_MAX_LENGTH; }
getDefaultMaxLength
36,919
BaseInspectionVisitor () { return new NamingConventionsVisitor(); }
buildVisitor
36,920
void (@NotNull GrField grField) { super.visitField(grField); if (!grField.hasModifierProperty(PsiModifier.STATIC) || !grField.hasModifierProperty(PsiModifier.FINAL)) { return; } final String name = grField.getName(); if (isValid(name)) { return; } registerVariableError(grField, name); }
visitField
36,921
String () { return myName; }
getFamilyName
36,922
void (@NotNull Project project, @NotNull PsiElement element, @NotNull ModPsiUpdater updater) { PsiElement elementToRemove = myElementFunction.fun(element); if (elementToRemove == null) return; elementToRemove.delete(); }
applyFix
36,923
void (@NotNull final ProgressIndicator progress) { ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex(); VirtualFile virtualFile = myFile.getViewProvider().getVirtualFile(); if (!fileIndex.isInContent(virtualFile)) { return; } final InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getCurrentProfile(); final HighlightDisplayKey unusedDefKey = HighlightDisplayKey.find(GroovyUnusedDeclarationInspection.SHORT_NAME); final boolean deadCodeEnabled = profile.isToolEnabled(unusedDefKey, myFile); final UnusedDeclarationInspectionBase deadCodeInspection = (UnusedDeclarationInspectionBase)profile.getUnwrappedTool(UnusedDeclarationInspectionBase.SHORT_NAME, myFile); final GroovyUsageHelper usageHelper = new GroovyUsageHelper(deadCodeInspection); final List<HighlightInfo> unusedDeclarations = new ArrayList<>(); final Map<GrParameter, Boolean> usedParams = new HashMap<>(); myFile.accept(new PsiRecursiveElementWalkingVisitor() { @Override public void visitElement(@NotNull PsiElement element) { if (element instanceof GrReferenceExpression && !((GrReferenceElement<?>)element).isQualified()) { GroovyResolveResult[] results = ((GrReferenceExpression)element).multiResolve(false); if (results.length == 0) { results = ((GrReferenceExpression)element).multiResolve(true); } for (GroovyResolveResult result : results) { PsiElement resolved = result.getElement(); if (resolved instanceof GrParameter && resolved.getContainingFile() == myFile) { usedParams.put((GrParameter)resolved, Boolean.TRUE); } } } if (deadCodeEnabled && element instanceof GrNamedElement && element instanceof PsiModifierListOwner && !UnusedSymbolUtil.isImplicitUsage(element.getProject(), (PsiModifierListOwner)element) && !GroovySuppressableInspectionTool.isElementToolSuppressedIn(element, GroovyUnusedDeclarationInspection.SHORT_NAME)) { PsiElement nameId = ((GrNamedElement)element).getNameIdentifierGroovy(); if (nameId.getNode().getElementType() == GroovyTokenTypes.mIDENT) { String name = ((GrNamedElement)element).getName(); if (element instanceof GrTypeDefinition && !UnusedSymbolUtil.isClassUsed(myProject, element.getContainingFile(), (GrTypeDefinition)element, progress, usageHelper )) { HighlightInfo.Builder builder = UnusedSymbolUtil .createUnusedSymbolInfoBuilder(nameId, GroovyBundle.message("text.class.0.is.unused", name), HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(element); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } else if (element instanceof GrMethod method) { if (SpockUtils.isUnusedInSpock(method, usageHelper)) { usageHelper.shouldCheckContributors = false; } try { if (!UnusedSymbolUtil.isMethodUsed(method.getProject(), method.getContainingFile(), method, progress, usageHelper)) { String message; if (method.isConstructor()) { message = GroovyBundle.message("text.constructor.0.is.unused", name); } else { message = GroovyBundle.message("text.method.0.is.unused", name); } HighlightInfo.Builder builder = UnusedSymbolUtil.createUnusedSymbolInfoBuilder(nameId, message, HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(method); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } } finally { usageHelper.shouldCheckContributors = true; } } else if (element instanceof GrField && isFieldUnused((GrField)element, progress, usageHelper)) { HighlightInfo.Builder builder = UnusedSymbolUtil.createUnusedSymbolInfoBuilder(nameId, GroovyBundle.message("text.property.0.is.unused", name), HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(element); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } else if (element instanceof GrParameter) { if (!usedParams.containsKey(element)) { usedParams.put((GrParameter)element, Boolean.FALSE); } } } } super.visitElement(element); } }); Set<GrImportStatement> unusedImports; myUnusedImports = unusedImports = unusedImports(myFile); if (deadCodeEnabled) { for (GrParameter parameter : usedParams.keySet()) { if (usedParams.get(parameter)) continue; PsiElement scope = parameter.getDeclarationScope(); if (scope instanceof GrMethod method) { if (methodMayHaveUnusedParameters(method)) { PsiElement identifier = parameter.getNameIdentifierGroovy(); HighlightInfo.Builder builder = UnusedSymbolUtil .createUnusedSymbolInfoBuilder(identifier, GroovyBundle.message("text.parameter.0.is.unused", parameter.getName()), HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = GroovyQuickFixFactory.getInstance().createRemoveUnusedGrParameterFix(parameter); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } } else if (scope instanceof GrClosableBlock) { //todo Max Medvedev } } } myUnusedDeclarations = unusedDeclarations; List<HighlightInfo> infos = convertUnusedImportsToInfos(unusedDeclarations, unusedImports); BackgroundUpdateHighlightersUtil.setHighlightersToEditor(myProject, myFile, myDocument, 0, myFile.getTextLength(), infos, getId()); }
doCollectInformation
36,924
void (@NotNull PsiElement element) { if (element instanceof GrReferenceExpression && !((GrReferenceElement<?>)element).isQualified()) { GroovyResolveResult[] results = ((GrReferenceExpression)element).multiResolve(false); if (results.length == 0) { results = ((GrReferenceExpression)element).multiResolve(true); } for (GroovyResolveResult result : results) { PsiElement resolved = result.getElement(); if (resolved instanceof GrParameter && resolved.getContainingFile() == myFile) { usedParams.put((GrParameter)resolved, Boolean.TRUE); } } } if (deadCodeEnabled && element instanceof GrNamedElement && element instanceof PsiModifierListOwner && !UnusedSymbolUtil.isImplicitUsage(element.getProject(), (PsiModifierListOwner)element) && !GroovySuppressableInspectionTool.isElementToolSuppressedIn(element, GroovyUnusedDeclarationInspection.SHORT_NAME)) { PsiElement nameId = ((GrNamedElement)element).getNameIdentifierGroovy(); if (nameId.getNode().getElementType() == GroovyTokenTypes.mIDENT) { String name = ((GrNamedElement)element).getName(); if (element instanceof GrTypeDefinition && !UnusedSymbolUtil.isClassUsed(myProject, element.getContainingFile(), (GrTypeDefinition)element, progress, usageHelper )) { HighlightInfo.Builder builder = UnusedSymbolUtil .createUnusedSymbolInfoBuilder(nameId, GroovyBundle.message("text.class.0.is.unused", name), HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(element); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } else if (element instanceof GrMethod method) { if (SpockUtils.isUnusedInSpock(method, usageHelper)) { usageHelper.shouldCheckContributors = false; } try { if (!UnusedSymbolUtil.isMethodUsed(method.getProject(), method.getContainingFile(), method, progress, usageHelper)) { String message; if (method.isConstructor()) { message = GroovyBundle.message("text.constructor.0.is.unused", name); } else { message = GroovyBundle.message("text.method.0.is.unused", name); } HighlightInfo.Builder builder = UnusedSymbolUtil.createUnusedSymbolInfoBuilder(nameId, message, HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(method); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } } finally { usageHelper.shouldCheckContributors = true; } } else if (element instanceof GrField && isFieldUnused((GrField)element, progress, usageHelper)) { HighlightInfo.Builder builder = UnusedSymbolUtil.createUnusedSymbolInfoBuilder(nameId, GroovyBundle.message("text.property.0.is.unused", name), HighlightInfoType.UNUSED_SYMBOL, GroovyUnusedDeclarationInspection.SHORT_NAME); IntentionAction action = QuickFixFactory.getInstance().createSafeDeleteFix(element); builder.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(unusedDefKey), null, unusedDefKey); ContainerUtil.addIfNotNull(unusedDeclarations, builder.create()); } else if (element instanceof GrParameter) { if (!usedParams.containsKey(element)) { usedParams.put((GrParameter)element, Boolean.FALSE); } } } } super.visitElement(element); }
visitElement
36,925
void () { Set<GrImportStatement> unusedImports = myUnusedImports; if (myUnusedDeclarations != null && unusedImports != null) { optimizeImports(unusedImports); } }
doApplyInformationToEditor
36,926
boolean (GrMethod method) { return (method.isConstructor() || method.hasModifierProperty(PsiModifier.PRIVATE) || method.hasModifierProperty(PsiModifier.STATIC) || !method.hasModifierProperty(PsiModifier.ABSTRACT) && !isOverriddenOrOverrides(method)) && !method.hasModifierProperty(PsiModifier.NATIVE) && !JavaHighlightUtil.isSerializationRelatedMethod(method, method.getContainingClass()) && !PsiClassImplUtil.isMainOrPremainMethod(method); }
methodMayHaveUnusedParameters
36,927
boolean (GrField field, ProgressIndicator progress, GlobalUsageHelper usageHelper) { if (UnusedSymbolUtil.isFieldUsed(field.getProject(), field.getContainingFile(), field, progress, usageHelper)) return false; final GrAccessorMethod[] getters = field.getGetters(); final GrAccessorMethod setter = field.getSetter(); for (GrAccessorMethod getter : getters) { if (getter.findSuperMethods().length > 0) { return false; } } if (setter != null) { if (setter.findSuperMethods().length > 0) { return false; } } return !UnusedSymbolUtil.isImplicitRead(field) && !UnusedSymbolUtil.isImplicitWrite(field); }
isFieldUnused
36,928
boolean (PsiMethod method) { boolean overrides = SuperMethodsSearch.search(method, null, true, false).findFirst() != null; return overrides || OverridingMethodsSearch.search(method).findFirst() != null; }
isOverriddenOrOverrides
36,929
void (@NotNull Collection<GrImportStatement> unusedImports) { if (!unusedImports.isEmpty()) { IntentionAction fix = GroovyQuickFixFactory.getInstance().createOptimizeImportsFix(true); if (fix.isAvailable(myProject, myEditor, myFile) && myFile.isWritable()) { fix.invoke(myProject, myEditor, myFile); } } }
optimizeImports
36,930
List<HighlightInfo> (@NotNull List<? extends HighlightInfo> unusedDeclarations, @NotNull Set<? extends GrImportStatement> unusedImports) { List<HighlightInfo> infos = new ArrayList<>(unusedDeclarations); for (GrImportStatement unusedImport : unusedImports) { IntentionAction action = GroovyQuickFixFactory.getInstance().createOptimizeImportsFix(false); HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.UNUSED_SYMBOL).range(calculateRangeToUse(unusedImport)) .descriptionAndTooltip(GroovyBundle.message("unused.import")) .registerFix(action, List.of(), null, null, null) .create(); if (info != null) { infos.add(info); } } return infos; }
convertUnusedImportsToInfos
36,931
TextRange (GrImportStatement unusedImport) { final TextRange range = unusedImport.getTextRange(); if (StringUtil.isEmptyOrSpaces(unusedImport.getAnnotationList().getText())) return range; int start = 0; for (PsiElement child = unusedImport.getFirstChild(); child != null; child = child.getNextSibling()) { if (child.getNode().getElementType() == GroovyTokenTypes.kIMPORT) { start = child.getTextRange().getStartOffset(); } } return new TextRange(start, range.getEndOffset()); }
calculateRangeToUse
36,932
boolean () { return false; }
isCurrentFileAlreadyChecked
36,933
boolean (@NotNull PsiNamedElement member) { return false; }
isLocallyUsed
36,934
boolean (@NotNull PsiMember member) { if (shouldCheckContributors) { return deadCodeInspection == null || !deadCodeInspection.isEntryPoint(member); } else { return true; } }
shouldCheckUsages
36,935
void (@NotNull TextEditorHighlightingPassRegistrar registrar, @NotNull Project project) { registrar.registerTextEditorHighlightingPass(this, new int[]{Pass.UPDATE_ALL}, null, true, -1); }
registerHighlightingPassFactory
36,936
TextEditorHighlightingPass (@NotNull PsiFile file, @NotNull Editor editor) { if (!(file instanceof GroovyFile)) return null; return new GroovyPostHighlightingPass((GroovyFile)file, editor); }
createHighlightingPass
36,937
void (@NotNull GroovyPsiElement element) { // do nothing & disable recursion }
visitElement
36,938
void (@NotNull GrTupleAssignmentExpression expression) { super.visitTupleAssignmentExpression(expression); final GrExpression initializer = expression.getRValue(); if (initializer != null) { checkTupleAssignment(initializer, expression.getLValue().getExpressions().length); } }
visitTupleAssignmentExpression
36,939
void (@NotNull GrVariableDeclaration variableDeclaration) { if (variableDeclaration.isTuple()) { GrExpression initializer = variableDeclaration.getTupleInitializer(); if (initializer != null) { checkTupleAssignment(initializer, variableDeclaration.getVariables().length); } } super.visitVariableDeclaration(variableDeclaration); }
visitVariableDeclaration
36,940
void (@NotNull GrExpression initializer, int leftCount) { Integer componentCount = getMultiAssignmentTypesCountCS(initializer); if (componentCount == null) { registerError( initializer, GroovyBundle.message("multiple.assignments.without.list.expr"), new LocalQuickFix[]{GroovyQuickFixFactory.getInstance().createMultipleAssignmentFix(leftCount)}, ProblemHighlightType.GENERIC_ERROR ); } else if (componentCount < leftCount) { registerError( initializer, GroovyBundle.message("incorrect.number.of.values", leftCount, componentCount), LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.GENERIC_ERROR ); } }
checkTupleAssignment
36,941
void (@NotNull GrSpreadArgument spreadArgument) { registerError( spreadArgument, GroovyBundle.message("spread.operator.is.not.available"), buildSpreadArgumentFix(spreadArgument), ProblemHighlightType.GENERIC_ERROR ); }
visitSpreadArgument
36,942
LocalQuickFix[] (GrSpreadArgument spreadArgument) { GrCallExpression parent = PsiTreeUtil.getParentOfType(spreadArgument, GrCallExpression.class); if (parent == null) return LocalQuickFix.EMPTY_ARRAY; PsiMethod resolveMethod = parent.resolveMethod(); if (resolveMethod == null) return LocalQuickFix.EMPTY_ARRAY; return new LocalQuickFix[]{GroovyQuickFixFactory.getInstance().createSpreadArgumentFix(resolveMethod.getParameters().length)}; }
buildSpreadArgumentFix
36,943
void (@NotNull PsiElement highlightElement, @NotNull ProblemHighlightType highlightType, @NotNull String message, @NotNull LocalQuickFix @NotNull ... fixes) { GroovyTypeCheckVisitor.this.registerError(highlightElement, message, fixes, highlightType); }
registerProblem
36,944
boolean (@Nullable PsiType expectedType, @NotNull GrExpression expression, @NotNull GroovyPsiElement elementToHighlight) { if (!(expectedType instanceof PsiClassType)) return false; if (!GroovyConfigUtils.getInstance().isVersionAtLeast(elementToHighlight, GroovyConfigUtils.GROOVY1_8)) return false; final PsiClass resolved = ((PsiClassType)expectedType).resolve(); if (resolved == null || !resolved.isEnum()) return false; final PsiType type = expression.getType(); if (type == null) return false; if (!type.equalsToText(GroovyCommonClassNames.GROOVY_LANG_GSTRING) && !type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) { return false; } final Object result = GroovyConstantExpressionEvaluator.evaluate(expression); if (!(result instanceof String)) { registerError( elementToHighlight, ProblemHighlightType.WEAK_WARNING, GroovyBundle.message("cannot.assign.string.to.enum.0", expectedType.getPresentableText()) ); } else { final PsiField field = resolved.findFieldByName((String)result, true); if (!(field instanceof PsiEnumConstant)) { registerError( elementToHighlight, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, GroovyBundle.message("cannot.find.enum.constant.0.in.enum.1", result, expectedType.getPresentableText()) ); } } return true; }
checkForImplicitEnumAssigning
36,945
void (@NotNull GrMethodCall call) { super.visitMethodCall(call); // visitExpression if (isFake(call)) return; GrArgumentList argumentList = call.getArgumentList(); if (hasErrorElements(argumentList)) return; GroovyMethodCallReference callReference = call.getCallReference(); if (callReference == null) { return; } PsiElement highlightElement; if (argumentList.getTextLength() == 0) { highlightElement = call; } else { highlightElement = argumentList; } CallReferenceHighlighter highlighter = new MethodCallReferenceHighlighter(callReference, highlightElement, myHighlightSink); if (highlighter.highlightMethodApplicability()) { return; } checkNamedArgumentsType(call); }
visitMethodCall
36,946
void (@NotNull GrCall call) { GrNamedArgument[] namedArguments = PsiUtil.getFirstMapNamedArguments(call); if (namedArguments.length == 0) return; Map<String, NamedArgumentDescriptor> map = GroovyNamedArgumentProvider.getNamedArgumentsFromAllProviders(call, null, false); if (map == null) return; checkNamedArguments(call, namedArguments, map); }
checkNamedArgumentsType
36,947
void (GroovyPsiElement context, GrNamedArgument[] namedArguments, Map<String, NamedArgumentDescriptor> map) { for (GrNamedArgument namedArgument : namedArguments) { String labelName = namedArgument.getLabelName(); NamedArgumentDescriptor descriptor = map.get(labelName); if (descriptor == null) continue; GrExpression namedArgumentExpression = namedArgument.getExpression(); if (namedArgumentExpression == null) continue; if (hasTupleInitializer(namedArgumentExpression)) continue; if (PsiUtil.isRawClassMemberAccess(namedArgumentExpression)) continue; PsiType expressionType = TypesUtil.boxPrimitiveType(namedArgumentExpression.getType(), context.getManager(), context.getResolveScope()); if (expressionType == null) continue; if (!descriptor.checkType(expressionType, context)) { registerError( namedArgumentExpression, ProblemHighlightType.GENERIC_ERROR, GroovyBundle.message("inspection.message.type.argument.0.can.not.be.1", labelName,expressionType.getPresentableText()) ); } } }
checkNamedArguments
36,948
void (@NotNull PsiType expectedType, @NotNull GrExpression expression, @NotNull PsiElement toHighlight, @NotNull PsiElement context) { checkPossibleLooseOfPrecision(expectedType, expression, toHighlight); processAssignment(expectedType, expression, toHighlight, "cannot.assign", context, Position.ASSIGNMENT); }
processAssignment
36,949
void (@NotNull PsiType lType, @Nullable PsiType rType, @NotNull GroovyPsiElement context, @NotNull PsiElement elementToHighlight) { if (rType == null) return; final ConversionResult result = TypesUtil.canAssign(lType, rType, context, Position.ASSIGNMENT); processResult(result, elementToHighlight, lType, rType, LocalQuickFix.EMPTY_ARRAY); }
processAssignment
36,950
void (@Nullable PsiType targetType, @Nullable PsiType actualType, @NotNull PsiElement elementToHighlight) { if (targetType == null || actualType == null) return; final ConversionResult result = TypesUtil.canAssignWithinMultipleAssignment(targetType, actualType); if (result == ConversionResult.OK) return; registerError( elementToHighlight, GroovyBundle.message("cannot.assign", actualType.getPresentableText(), targetType.getPresentableText()), LocalQuickFix.EMPTY_ARRAY, result == ConversionResult.ERROR ? ProblemHighlightType.GENERIC_ERROR : ProblemHighlightType.GENERIC_ERROR_OR_WARNING ); }
processAssignmentWithinMultipleAssignment
36,951
void (@NotNull GrTupleAssignmentExpression expression) { super.visitTupleAssignmentExpression(expression); // visitExpression GrExpression initializer = expression.getRValue(); if (initializer == null) return; GrTuple tupleExpression = expression.getLValue(); GrExpression[] lValues = tupleExpression.getExpressions(); if (initializer instanceof GrListOrMap) { GrExpression[] initializers = ((GrListOrMap)initializer).getInitializers(); for (int i = 0; i < lValues.length; i++) { GrExpression lValue = lValues[i]; if (initializers.length <= i) break; GrExpression rValue = initializers[i]; processAssignmentWithinMultipleAssignment(lValue.getType(), rValue.getType(), rValue); } } else { MultiAssignmentTypes multiAssignmentTypes = getMultiAssignmentTypes(initializer); if (multiAssignmentTypes == null) { return; } for (int position = 0; position < lValues.length; position++) { PsiType rType = multiAssignmentTypes.getComponentType(position); GrExpression lValue = lValues[position]; // For assignments with spread dot if (PsiImplUtil.isSpreadAssignment(lValue)) { if (rType != null) { PsiType lType = lValue.getNominalType(); final PsiType argType = extractIterableTypeParameter(lType, false); if (argType != null) { processAssignment(argType, rType, tupleExpression, getExpressionPartToHighlight(lValue)); } } return; } if (lValue instanceof GrReferenceExpression && ((GrReferenceExpression)lValue).resolve() instanceof GrReferenceExpression) { //lvalue is not-declared variable return; } if (rType != null) { PsiType lType = lValue.getNominalType(); if (lType != null) { processAssignment(lType, rType, tupleExpression, getExpressionPartToHighlight(lValue)); } } } } }
visitTupleAssignmentExpression
36,952
void (@NotNull ConversionResult result, @NotNull PsiElement elementToHighlight, @NotNull PsiType lType, @NotNull PsiType rType, LocalQuickFix @NotNull [] fixes) { if (result == ConversionResult.OK) return; registerError( elementToHighlight, GroovyBundle.message("cannot.assign", rType.getPresentableText(), lType.getPresentableText()), fixes, result == ConversionResult.ERROR ? ProblemHighlightType.GENERIC_ERROR : ProblemHighlightType.GENERIC_ERROR_OR_WARNING ); }
processResult
36,953
void (@NotNull GrExpression expression, @NotNull PsiElement context, @NotNull PsiElement elementToHighlight) { if (hasTupleInitializer(expression)) return; final PsiType returnType = PsiImplUtil.inferReturnType(expression); if (returnType == null || PsiTypes.voidType().equals(returnType)) return; processAssignment(returnType, expression, elementToHighlight, "cannot.return.type", context, Position.RETURN_VALUE); }
processReturnValue
36,954
void (@NotNull PsiElement location, @InspectionMessage @NotNull String description, @NotNull LocalQuickFix @Nullable [] fixes, ProblemHighlightType highlightType) { if (FileTypeInspectionDisablerKt.isTypecheckingDisabled(location.getContainingFile())) { return; } if (CompileStaticUtil.isCompileStatic(location)) { // filter all errors here, error will be highlighted by annotator if (highlightType != ProblemHighlightType.GENERIC_ERROR) { super.registerError(location, description, fixes, highlightType); } } else { if (highlightType == ProblemHighlightType.GENERIC_ERROR) { // if this visitor works within non-static context we will highlight all errors as warnings super.registerError(location, description, fixes, ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } else { // if this visitor works within static context errors will be highlighted as errors by annotator, warnings will be highlighted as warnings here super.registerError(location, description, fixes, highlightType); } } }
registerError
36,955
void (@NotNull GrReturnStatement returnStatement) { final GrExpression value = returnStatement.getReturnValue(); if (value != null) { processReturnValue(value, returnStatement, returnStatement.getReturnWord()); } }
visitReturnStatement
36,956
void (@NotNull GrThrowStatement throwStatement) { final GrExpression exception = throwStatement.getException(); if (exception == null) return; final PsiElement throwWord = throwStatement.getFirstChild(); processAssignment( PsiType.getJavaLangThrowable( throwStatement.getManager(), throwStatement.getResolveScope() ), exception, throwWord, throwWord ); }
visitThrowStatement
36,957
void (@NotNull GrExpression expression) { if (isImplicitReturnStatement(expression)) { processReturnValue(expression, expression, expression); } }
visitExpression
36,958
void (@NotNull GrNewExpression newExpression) { super.visitNewExpression(newExpression); // visitExpression if (hasErrorElements(newExpression) || hasErrorElements(newExpression.getArgumentList())) return; final GroovyCallReference reference = newExpression.getConstructorReference(); if (reference == null) return; if (new GrNewExpressionHighlighter(newExpression, reference, myHighlightSink).highlight()) { return; } checkNamedArgumentsType(newExpression); }
visitNewExpression
36,959
void (@NotNull GrEnumConstant enumConstant) { if (hasErrorElements(enumConstant) || hasErrorElements(enumConstant.getArgumentList())) return; if (new GrEnumConstantHighlighter(enumConstant, myHighlightSink).highlight()) { return; } checkNamedArgumentsType(enumConstant); }
visitEnumConstant
36,960
void (@NotNull GrConstructorInvocation invocation) { if (hasErrorElements(invocation) || hasErrorElements(invocation.getArgumentList())) return; if (new GrConstructorInvocationHighlighter(invocation, myHighlightSink).highlight()) { return; } checkNamedArgumentsType(invocation); }
visitConstructorInvocation
36,961
void (@NotNull GrAssignmentExpression assignment) { super.visitAssignmentExpression(assignment); // visitExpression if (assignment.isOperatorAssignment()) return; final GrExpression lValue = assignment.getLValue(); if (!PsiUtil.mightBeLValue(lValue)) return; final GrExpression rValue = assignment.getRValue(); if (rValue == null) return; if (lValue instanceof GrReferenceExpression && ((GrReferenceExpression)lValue).resolve() instanceof GrReferenceExpression) { //lvalue is not-declared variable return; } PsiType lValueNominalType = lValue.getNominalType(); final PsiType targetType = PsiImplUtil.isSpreadAssignment(lValue) ? extractIterableTypeParameter(lValueNominalType, false) : lValueNominalType; if (targetType == null) return; processAssignment(targetType, rValue, lValue, assignment); }
visitAssignmentExpression
36,962
void (@NotNull GrBinaryExpression binary) { super.visitBinaryExpression(binary); // visitExpression GroovyCallReference reference = binary.getReference(); if (reference == null) return; new BinaryExpressionHighlighter(binary, reference, myHighlightSink).highlight(); }
visitBinaryExpression
36,963
void (@NotNull GrTypeCastExpression expression) { super.visitCastExpression(expression); // visitExpression final GrExpression operand = expression.getOperand(); if (operand == null) return; final PsiType actualType = operand.getType(); if (actualType == null) return; if (expression.getCastTypeElement() == null) return; final PsiType expectedType = expression.getCastTypeElement().getType(); final ConversionResult result = TypesUtil.canCast(expectedType, actualType, expression); if (result == ConversionResult.OK) return; final ProblemHighlightType highlightType = result == ConversionResult.ERROR ? ProblemHighlightType.GENERIC_ERROR : ProblemHighlightType.GENERIC_ERROR_OR_WARNING; final String message = GroovyBundle.message( "cannot.cast", actualType.getPresentableText(), expectedType.getPresentableText() ); registerError( expression, highlightType, message ); }
visitCastExpression
36,964
void (@NotNull GrIndexProperty expression) { super.visitIndexProperty(expression); // visitExpression if (hasErrorElements(expression)) return; if (GroovyIndexPropertyUtil.isClassLiteral(expression)) return; if (GroovyIndexPropertyUtil.isSimpleArrayAccess(expression)) return; GrArgumentList argumentList = expression.getArgumentList(); GroovyMethodCallReference rValueReference = expression.getRValueReference(); if (rValueReference != null) { new MethodCallReferenceHighlighter(rValueReference, argumentList, myHighlightSink).highlightMethodApplicability(); } GroovyMethodCallReference lValueReference = expression.getLValueReference(); if (lValueReference != null) { new MethodCallReferenceHighlighter(lValueReference, argumentList, myHighlightSink).highlightMethodApplicability(); } }
visitIndexProperty
36,965
void (@NotNull GrMethod method) { final PsiTypeParameter[] parameters = method.getTypeParameters(); final Map<PsiTypeParameter, PsiType> map = new HashMap<>(); for (PsiTypeParameter parameter : parameters) { final PsiClassType[] types = parameter.getSuperTypes(); final PsiType bound = PsiIntersectionType.createIntersection(types); final PsiWildcardType wildcardType = PsiWildcardType.createExtends(method.getManager(), bound); map.put(parameter, wildcardType); } final PsiSubstitutor substitutor = PsiSubstitutor.createSubstitutor(map); for (GrParameter parameter : method.getParameterList().getParameters()) { final GrExpression initializer = parameter.getInitializerGroovy(); if (initializer == null) continue; final PsiType targetType = parameter.getType(); processAssignment( substitutor.substitute(targetType), initializer, parameter.getNameIdentifierGroovy(), parameter ); } }
visitMethod
36,966
void (@NotNull final GrParameterList parameterList) { PsiElement parent = parameterList.getParent(); if (!(parent instanceof GrFunctionalExpression)) return; GrParameter[] parameters = parameterList.getParameters(); if (parameters.length > 0) { List<PsiType[]> signatures = ClosureParamsEnhancer.findFittingSignatures((GrFunctionalExpression)parent); // TODO: suspicious method call final List<PsiType> paramTypes = ContainerUtil.map(parameters, parameter -> parameter.getType()); if (signatures.size() > 1) { final PsiType[] fittingSignature = ContainerUtil.find(signatures, types -> { for (int i = 0; i < types.length; i++) { if (!TypesUtil.isAssignableByMethodCallConversion(paramTypes.get(i), types[i], parameterList)) { return false; } } return true; }); if (fittingSignature == null) { registerError( parameterList, GroovyBundle.message("no.applicable.signature.found"), null, ProblemHighlightType.GENERIC_ERROR ); } } else if (signatures.size() == 1) { PsiType[] types = signatures.get(0); for (int i = 0; i < types.length; i++) { GrTypeElement typeElement = parameters[i].getTypeElementGroovy(); if (typeElement == null) continue; PsiType expected = types[i]; PsiType actual = paramTypes.get(i); if (!TypesUtil.isAssignableByMethodCallConversion(actual, expected, parameterList)) { registerError( typeElement, GroovyBundle.message("expected.type.0", expected.getCanonicalText(false), actual.getCanonicalText(false)), null, ProblemHighlightType.GENERIC_ERROR ); } } } } }
visitParameterList
36,967
void (@NotNull GrForInClause forInClause) { final GrVariable variable = forInClause.getDeclaredVariable(); final GrExpression iterated = forInClause.getIteratedExpression(); if (variable == null || iterated == null) return; final PsiType iteratedType = ClosureParameterEnhancer.findTypeForIteration(iterated, forInClause); if (iteratedType == null) return; final PsiType targetType = variable.getType(); final ConversionResult result = TypesUtil.canAssign(targetType, iteratedType, forInClause, Position.ASSIGNMENT); LocalQuickFix[] fixes = {new GrCastFix(TypesUtil.createListType(iterated, targetType), iterated)}; processResult(result, variable, targetType, iteratedType, fixes); }
visitForInClause
36,968
void (@NotNull GrVariable variable) { final PsiType varType = variable.getType(); final PsiElement parent = variable.getParent(); if (variable instanceof GrParameter && ((GrParameter)variable).getDeclarationScope() instanceof GrMethod || parent instanceof GrForInClause) { return; } GrExpression initializer = variable.getInitializerGroovy(); if (initializer != null) { processAssignment(varType, initializer, variable.getNameIdentifierGroovy(), variable); } else { PsiType initializerType = variable.getInitializerType(); processAssignment(varType, initializerType, variable, variable.getNameIdentifierGroovy()); } }
visitVariable
36,969
void (@NotNull GrListOrMap listOrMap) { super.visitListOrMap(listOrMap); // visitExpression GroovyConstructorReference constructorReference = listOrMap.getConstructorReference(); if (constructorReference != null) { CallReferenceHighlighter highlighter = new LiteralConstructorReferenceHighlighter(constructorReference, listOrMap, myHighlightSink); if (highlighter.highlightMethodApplicability()) { return; } } Map<String, NamedArgumentDescriptor> descriptors = NamedArgumentUtilKt.getDescriptors(listOrMap); if (descriptors.isEmpty()) return; GrNamedArgument[] namedArguments = listOrMap.getNamedArguments(); if (namedArguments.length == 0) return; checkNamedArguments(listOrMap, namedArguments, descriptors); }
visitListOrMap
36,970
void (@NotNull PsiElement location, ProblemHighlightType highlightType, @InspectionMessage Object... args) { registerError(location, (String)args[0], LocalQuickFix.EMPTY_ARRAY, highlightType); }
registerError
36,971
boolean (@Nullable GrExpression initializer) { return initializer instanceof GrListOrMap && ((GrListOrMap)initializer).getConstructorReference() != null; }
hasTupleInitializer
36,972
PsiElement (@NotNull GrExpression expr) { return expr instanceof GrClosableBlock ? ((GrClosableBlock)expr).getLBrace() : expr; }
getExpressionPartToHighlight
36,973
boolean (@Nullable PsiElement e) { if (e == null) return false; for (PsiElement child = e.getFirstChild(); child != null; child = child.getNextSibling()) { if (child instanceof PsiErrorElement) return true; } return false; }
hasErrorElements
36,974
boolean (GrBinaryExpression binary, GroovyResolveResult result) { if (result.getElement() != null && result.isApplicable()) { return false; } GrExpression left = binary.getLeftOperand(); GrExpression right = binary.getRightOperand(); PsiType ltype = left.getType(); PsiType rtype = right != null ? right.getType() : null; return TypesUtil.isNumericType(ltype) && (rtype == null || TypesUtil.isNumericType(rtype)); }
isOperatorWithSimpleTypes
36,975
String (@NotNull PsiElement highlight) { final PsiElement parent = highlight.getParent(); if (parent instanceof GrVariable) { return ((GrVariable)parent).getName(); } else if (highlight instanceof GrReferenceExpression && parent instanceof GrAssignmentExpression && ((GrAssignmentExpression)parent).getLValue() == highlight) { final PsiElement resolved = ((GrReferenceExpression)highlight).resolve(); if (resolved instanceof GrVariable && PsiUtil.isLocalVariable(resolved)) { return ((GrVariable)resolved).getName(); } } return null; }
getLValueVarName
36,976
List<GrExpression> (@NotNull GrArgumentList argumentList) { final ArrayList<GrExpression> args = new ArrayList<>(); for (GroovyPsiElement arg : argumentList.getAllArguments()) { if (arg instanceof GrSpreadArgument) { GrExpression spreaded = ((GrSpreadArgument)arg).getArgument(); if (spreaded instanceof GrListOrMap && !((GrListOrMap)spreaded).isMap()) { Collections.addAll(args, ((GrListOrMap)spreaded).getInitializers()); } else { return null; } } else if (arg instanceof GrExpression) { args.add((GrExpression)arg); } else if (arg instanceof GrNamedArgument) { args.add(((GrNamedArgument)arg).getExpression()); } } final PsiElement parent = argumentList.getParent(); if (parent instanceof GrIndexProperty && PsiUtil.isLValue((GroovyPsiElement)parent)) { args.add(TypeInferenceHelper.getInitializerFor((GrExpression)parent)); } else if (parent instanceof GrMethodCallExpression) { ContainerUtil.addAll(args, ((GrMethodCallExpression)parent).getClosureArguments()); } return args; }
getExpressionArgumentsOfCall
36,977
LocalQuickFix[] (PsiElement location, GroovyResolveResult resolveResult) { final PsiElement element = resolveResult.getElement(); if (!(element instanceof PsiMember refElement)) return GroovyFix.EMPTY_ARRAY; if (refElement instanceof PsiCompiledElement) return GroovyFix.EMPTY_ARRAY; PsiModifierList modifierList = refElement.getModifierList(); if (modifierList == null) return GroovyFix.EMPTY_ARRAY; List<LocalQuickFix> fixes = new ArrayList<>(); try { Project project = refElement.getProject(); JavaPsiFacade facade = JavaPsiFacade.getInstance(project); PsiModifierList modifierListCopy = facade.getElementFactory().createFieldFromText("int a;", null).getModifierList(); assert modifierListCopy != null; modifierListCopy.setModifierProperty(PsiModifier.STATIC, modifierList.hasModifierProperty(PsiModifier.STATIC)); String minModifier = PsiModifier.PROTECTED; if (refElement.hasModifierProperty(PsiModifier.PROTECTED)) { minModifier = PsiModifier.PUBLIC; } String[] modifiers = {PsiModifier.PROTECTED, PsiModifier.PUBLIC, PsiModifier.PACKAGE_LOCAL}; PsiClass accessObjectClass = PsiTreeUtil.getParentOfType(location, PsiClass.class, false); if (accessObjectClass == null) { final PsiFile file = location.getContainingFile(); if (!(file instanceof GroovyFile)) return GroovyFix.EMPTY_ARRAY; accessObjectClass = ((GroovyFile)file).getScriptClass(); } for (int i = ArrayUtil.indexOf(modifiers, minModifier); i < modifiers.length; i++) { String modifier = modifiers[i]; modifierListCopy.setModifierProperty(modifier, true); if (facade.getResolveHelper().isAccessible(refElement, modifierListCopy, location, accessObjectClass, null)) { fixes.add(new GrModifierFix(refElement, modifier, true, true, GrModifierFix.MODIFIER_LIST_OWNER)); } } } catch (IncorrectOperationException e) { LOG.error(e); } return fixes.toArray(LocalQuickFix.EMPTY_ARRAY); }
buildFixes
36,978
HighlightInfo (@NotNull GrCodeReferenceElement ref) { HighlightInfo.Builder builder = checkReferenceImpl(ref); return builder==null?null:builder.create(); }
checkCodeReferenceElement
36,979
void (GrReferenceElement<?> ref, GroovyResolveResult result, @NotNull HighlightInfo.Builder info, @NotNull HighlightSeverity severity) { PsiElement element = result.getElement(); assert element != null; if (element instanceof LightElement) return; LocalQuickFix[] fixes = buildFixes(ref, result); if (fixes.length == 0) { String displayName = HighlightDisplayKey.getDisplayNameByKey(myDisplayKey); if (displayName != null) { IntentionAction action = new EmptyIntentionAction(displayName); info.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(myDisplayKey), null, myDisplayKey); } } else { ProblemDescriptor descriptor = InspectionManager.getInstance(ref.getProject()). createProblemDescriptor(element, element, "", HighlightInfo.convertSeverityToProblemHighlight(severity), true, fixes); for (int i = 0; i < fixes.length; i++) { IntentionAction action = QuickFixWrapper.wrap(descriptor, i); info.registerFix(action, null, HighlightDisplayKey.getDisplayNameByKey(myDisplayKey), null, myDisplayKey); } } }
registerFixes
36,980
HighlightInfo (@NotNull GrReferenceExpression ref) { HighlightInfo.Builder builder = checkReferenceImpl(ref); return builder==null?null:builder.create(); }
checkReferenceExpression
36,981
boolean (GroovyResolveResult result) { return result != null && result.getElement() != null && !result.isAccessible(); }
checkResolveResult
36,982
boolean (GrReferenceElement<?> ref, boolean isCompileStatic) { if (isCompileStatic) return true; if (!myInspectionEnabled) return false; if (GroovyAccessibilityInspection.isSuppressed(ref)) return false; return true; }
needToCheck
36,983
String (PsiMember member, boolean showContainingClass) { if (showContainingClass) { final PsiClass containingClass = member.getContainingClass(); String containingClassName = containingClass != null ? containingClass.getName() + "." : ""; return containingClassName + member.getName(); } else { return member.getName(); } }
getMemberName
36,984
String (String modifier) { return GroovyBundle.message(modifier + ".visibility.presentation"); }
toPresentableText
36,985
String () { return myText; }
getName
36,986
String () { return GroovyBundle.message("change.modifier.family.name"); }
getFamilyName
36,987
ModCommand (@NotNull Project project, @NotNull ProblemDescriptor descriptor) { final PsiModifierList modifierList = getModifierList(descriptor); return ModCommand.psiUpdate(modifierList, m -> m.setModifierProperty(myModifier, myDoSet)); }
perform
36,988
PsiModifierList (ProblemDescriptor descriptor) { return myModifierListProvider.fun(descriptor); }
getModifierList
36,989
String (Object... args) { return GroovyBundle.message("inspection.message.ref.statement.cannot.complete.without.throwing.exception"); }
buildErrorString
36,990
BaseInspectionVisitor () { return new Visitor(); }
buildVisitor
36,991
void (@NotNull GrWhileStatement whileStatement) { super.visitWhileStatement(whileStatement); if (ControlFlowUtils.statementMayCompleteNormally(whileStatement)) { return; } if (ControlFlowUtils.statementContainsReturn(whileStatement)) { return; } registerStatementError(whileStatement); }
visitWhileStatement
36,992
String (Object... args) { return GroovyBundle.message("inspection.message.code.ref.code.recurses.infinitely.can.only.complete.by.throwing.exception"); }
buildErrorString
36,993
BaseInspectionVisitor () { return new Visitor(); }
buildVisitor
36,994
void (@NotNull GrMethod method) { super.visitMethod(method); if (method.hasModifierProperty(PsiModifier.ABSTRACT)) { return; } if (!RecursionUtils.methodMayRecurse(method)) { return; } if (!RecursionUtils.methodDefinitelyRecurses(method)) { return; } registerMethodError(method); }
visitMethod
36,995
boolean ( @Nullable GrStatement statement, GrMethod method) { if (statement == null) { return true; } if (statement instanceof GrBreakStatement || statement instanceof GrContinueStatement || statement instanceof GrThrowStatement || statement instanceof GrExpression || statement instanceof GrAssertStatement || statement instanceof GrVariableDeclaration) { return false; } else if (statement instanceof GrReturnStatement returnStatement) { final GrExpression returnValue = returnStatement.getReturnValue(); if (returnValue != null) { if (expressionDefinitelyRecurses(returnValue, method)) { return false; } } return true; } else if (statement instanceof GrForStatement) { return forStatementMayReturnBeforeRecursing( (GrForStatement) statement, method); } else if (statement instanceof GrWhileStatement) { return whileStatementMayReturnBeforeRecursing( (GrWhileStatement) statement, method); } else if (statement instanceof GrSynchronizedStatement) { final GrCodeBlock body = ((GrSynchronizedStatement) statement) .getBody(); return codeBlockMayReturnBeforeRecursing(body, method, false); } else if (statement instanceof GrBlockStatement blockStatement) { final GrCodeBlock codeBlock = blockStatement.getBlock(); return codeBlockMayReturnBeforeRecursing(codeBlock, method, false); } else if (statement instanceof GrIfStatement) { return ifStatementMayReturnBeforeRecursing( (GrIfStatement) statement, method); } else if (statement instanceof GrTryCatchStatement) { return tryStatementMayReturnBeforeRecursing( (GrTryCatchStatement) statement, method); } else if (statement instanceof GrSwitchStatement) { return switchStatementMayReturnBeforeRecursing( (GrSwitchStatement) statement, method); } else { // unknown statement type return true; } }
statementMayReturnBeforeRecursing
36,996
boolean ( GrWhileStatement loopStatement, GrMethod method) { final GrExpression condition = loopStatement.getCondition(); if (condition == null) { return false; } if (expressionDefinitelyRecurses(condition, method)) { return false; } final GrStatement body = loopStatement.getBody(); return statementMayReturnBeforeRecursing(body, method); }
whileStatementMayReturnBeforeRecursing
36,997
boolean ( GrForStatement loopStatement, GrMethod method) { final GrForClause forClause = loopStatement.getClause(); if (forClause != null) { for (GrVariable var : forClause.getDeclaredVariables()) { final GrExpression initializer = var.getInitializerGroovy(); if (expressionDefinitelyRecurses(initializer, method)) { return false; } } } final GrStatement body = loopStatement.getBody(); return statementMayReturnBeforeRecursing(body, method); }
forStatementMayReturnBeforeRecursing
36,998
boolean ( GrSwitchStatement switchStatement, GrMethod method) { final GrCaseSection[] caseSections = switchStatement.getCaseSections(); for (GrCaseSection caseSection : caseSections) { final GrStatement[] statements = caseSection.getStatements(); for (final GrStatement statement : statements) { if (statementMayReturnBeforeRecursing(statement, method)) { return true; } } } return false; }
switchStatementMayReturnBeforeRecursing
36,999
boolean ( GrTryCatchStatement tryStatement, GrMethod method) { final GrFinallyClause finallyBlock = tryStatement.getFinallyClause(); if (finallyBlock != null) { final GrOpenBlock body = finallyBlock.getBody(); if (codeBlockMayReturnBeforeRecursing(body, method, false)) { return true; } if (codeBlockDefinitelyRecurses(body, method)) { return false; } } final GrCodeBlock tryBlock = tryStatement.getTryBlock(); if (codeBlockMayReturnBeforeRecursing(tryBlock, method, false)) { return true; } final GrCatchClause[] catchBlocks = tryStatement.getCatchClauses(); for (final GrCatchClause catchBlock : catchBlocks) { if (codeBlockMayReturnBeforeRecursing(catchBlock.getBody(), method, false)) { return true; } } return false; }
tryStatementMayReturnBeforeRecursing