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
29,100
GrSignature (GrParameterListOwner owner, GrReferenceExpression refExpr) { if (owner instanceof PsiMethod) { final GroovyResolveResult resolveResult = refExpr.advancedResolve(); final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); return GrClosureSignatureUtil.createSignature((PsiMethod)owner, substitutor); } else if (owner instanceof GrClosableBlock) { return GrClosureSignatureUtil.createSignature((GrClosableBlock)owner); } return null; }
generateSignature
29,101
FIRST_PARAMETER_KIND (final GrParameterListOwner owner, final Collection<PsiElement> occurrences) { boolean thereAreNamedArguments = false; for (PsiElement occurrence : occurrences) { if (occurrence instanceof GrReferenceExpression && occurrence.getParent() instanceof GrCall call) { final GrArgumentList args = call.getArgumentList(); if (args != null && args.getNamedArguments().length > 0) { thereAreNamedArguments = true; } } if (thereAreNamedArguments) break; } if (thereAreNamedArguments) { if (firstOwnerParameterMustBeMap(owner)) { return FIRST_PARAMETER_KIND.MUST_BE_MAP; } return FIRST_PARAMETER_KIND.ERROR; } return FIRST_PARAMETER_KIND.IS_NOT_MAP; }
analyzeForNamedArguments
29,102
boolean (final GrParameterListOwner owner) { final GrParameter first = getFirstParameter(owner); final PsiType type = first.getTypeGroovy(); if (type == null) return true; // First parameter may be used as map return type.isConvertibleFrom(createTypeByFQClassName(JAVA_UTIL_LINKED_HASH_MAP, owner)); }
firstOwnerParameterMustBeMap
29,103
GrParameter (final GrParameterListOwner owner) { final GrParameter[] params = owner.getParameters(); LOG.assertTrue(params.length > 0); return params[0]; }
getFirstParameter
29,104
GrNamedElement (final GrParameterListOwner owner) { if (owner instanceof GrMethodImpl) return ((GrMethodImpl)owner); if (owner instanceof GrClosableBlock) { final PsiElement parent = owner.getParent(); if (parent instanceof GrVariable && ((GrVariable)parent).getInitializerGroovy() == owner) return ((GrVariable)parent); } return null; }
getReferencedElement
29,105
boolean (final Project project, final Collection<PsiElement> occurrences, final boolean isClosure) { boolean result = true; final StringBuilder msg = new StringBuilder(); msg.append( isClosure ? GroovyBundle.message("conversion.closure.not.allowed.in.non.groovy.files") : GroovyBundle.message("conversion.method.not.allowed.in.non.groovy.files") ); for (PsiElement element : occurrences) { final PsiFile file = element.getContainingFile(); if (!(file instanceof GroovyFileBase)) { result = false; msg.append("\n").append(file.getName()); } } if (!result) { @NlsSafe String message = msg.toString(); showErrorMessage(message, project); return false; } return true; }
checkOwnerOccurrences
29,106
boolean (final Project project, final GrParameterListOwner owner, final Collection<PsiElement> occurrences) { final PsiElement namedElem = getReferencedElement(owner); if (namedElem == null) return true; final Ref<Boolean> result = new Ref<>(true); final Task task = new Task.Modal( project, owner instanceof GrClosableBlock ? GroovyBundle.message("find.method.ro.closure.usages") : GroovyBundle.message("find.method.ro.method.usages"), true ) { @Override public void run(@NotNull final ProgressIndicator indicator) { final Collection<PsiReference> references = Collections.synchronizedSet(new HashSet<>()); final Processor<PsiReference> consumer = psiReference -> { references.add(psiReference); return true; }; ReferencesSearch.search(namedElem).forEach(consumer); boolean isProperty = ReadAction.compute(() -> namedElem instanceof GrField && ((GrField)namedElem).isProperty()); if (isProperty) { final GrAccessorMethod[] getters = ReadAction.compute(() -> ((GrField)namedElem).getGetters()); for (GrAccessorMethod getter : getters) { MethodReferencesSearch.search(getter).forEach(consumer); } } for (final PsiReference reference : references) { ApplicationManager.getApplication().runReadAction(() -> { final PsiElement element = reference.getElement(); occurrences.add(element); }); } } @Override public void onCancel() { result.set(false); } @Override public void onThrowable(@NotNull Throwable error) { super.onThrowable(error); result.set(false); } @Override public void onSuccess() { result.set(true); } }; ProgressManager.getInstance().run(task); return result.get().booleanValue(); }
collectOwnerOccurrences
29,107
void (@NotNull final ProgressIndicator indicator) { final Collection<PsiReference> references = Collections.synchronizedSet(new HashSet<>()); final Processor<PsiReference> consumer = psiReference -> { references.add(psiReference); return true; }; ReferencesSearch.search(namedElem).forEach(consumer); boolean isProperty = ReadAction.compute(() -> namedElem instanceof GrField && ((GrField)namedElem).isProperty()); if (isProperty) { final GrAccessorMethod[] getters = ReadAction.compute(() -> ((GrField)namedElem).getGetters()); for (GrAccessorMethod getter : getters) { MethodReferencesSearch.search(getter).forEach(consumer); } } for (final PsiReference reference : references) { ApplicationManager.getApplication().runReadAction(() -> { final PsiElement element = reference.getElement(); occurrences.add(element); }); } }
run
29,108
void () { result.set(false); }
onCancel
29,109
void (@NotNull Throwable error) { super.onThrowable(error); result.set(false); }
onThrowable
29,110
void () { result.set(true); }
onSuccess
29,111
PsiElementPredicate () { return new MyPsiElementPredicate(); }
getElementPredicate
29,112
boolean (@NotNull final PsiElement element) { GrParameter parameter = null; if (element instanceof GrParameter) { parameter = (GrParameter)element; } else if (element instanceof GrReferenceExpression expr) { if (expr.getQualifierExpression() != null) return false; final PsiElement resolved = expr.resolve(); if (resolved instanceof GrParameter) { parameter = (GrParameter)resolved; } } if (parameter == null) return false; if (parameter.isOptional()) return false; GrParameterListOwner owner = PsiTreeUtil.getParentOfType(element, GrParameterListOwner.class); return owner != null && checkForMapParameters(owner); }
satisfiedBy
29,113
boolean (GrParameterListOwner owner) { final GrParameter[] parameters = owner.getParameters(); if (parameters.length != 1) return true; final GrParameter parameter = parameters[0]; final PsiType type = parameter.getTypeGroovy(); if (!(type instanceof PsiClassType)) return true; final PsiClass psiClass = ((PsiClassType)type).resolve(); return psiClass == null || !CommonClassNames.JAVA_UTIL_MAP.equals(psiClass.getQualifiedName()); }
checkForMapParameters
29,114
void (@DialogMessage String message, final Project project) { CommonRefactoringUtil.showErrorMessage(GroovyBundle.message("convert.parameter.to.map.entry.title"), message, null, project); }
showErrorMessage
29,115
boolean (final MultiMap<PsiElement, String> conflicts, final Project project) { if (conflicts.isEmpty()) return true; ConflictsDialog conflictsDialog = new ConflictsDialog(project, conflicts); return conflictsDialog.showAndGet(); }
reportConflicts
29,116
void (final @NlsSafe String[] possibleNames, boolean createNew) { setTitle(GroovyBundle.message("convert.param.to.map.entry")); if (GroovyApplicationSettings.getInstance().CONVERT_PARAM_CREATE_NEW_PARAM != null) { myCreateNew.setSelected(createNew = GroovyApplicationSettings.getInstance().CONVERT_PARAM_CREATE_NEW_PARAM.booleanValue()); } else { myCreateNew.setSelected(createNew); } myNameLabel.setLabelFor(myNameComboBox); myCbTypeSpec.setMnemonic(KeyEvent.VK_T); myCbTypeSpec.setFocusable(false); setUpNameComboBox(possibleNames); setModal(true); if (GroovyApplicationSettings.getInstance().CONVERT_PARAM_SPECIFY_MAP_TYPE != null) { myCbTypeSpec.setSelected(GroovyApplicationSettings.getInstance().CONVERT_PARAM_SPECIFY_MAP_TYPE.booleanValue()); } else { myCbTypeSpec.setSelected(true); } myCbTypeSpec.setEnabled(createNew); myNameComboBox.setEnabled(createNew); myNameLabel.setEnabled(createNew); myCreateNew.addChangeListener(new ChangeListener() { @Override public void stateChanged(final ChangeEvent e) { final boolean flag = myCreateNew.isSelected(); myCbTypeSpec.setEnabled(flag); myNameComboBox.setEnabled(flag); myNameLabel.setEnabled(flag); } }); }
setUpDialog
29,117
void (final ChangeEvent e) { final boolean flag = myCreateNew.isSelected(); myCbTypeSpec.setEnabled(flag); myNameComboBox.setEnabled(flag); myNameLabel.setEnabled(flag); }
stateChanged
29,118
boolean () { return myCreateNew.isSelected(); }
createNewFirst
29,119
JComponent () { return myNameComboBox; }
getPreferredFocusedComponent
29,120
boolean () { return myCbTypeSpec.isSelected(); }
specifyTypeExplicitly
29,121
void () { if (myCbTypeSpec.isEnabled()) { GroovyApplicationSettings.getInstance().CONVERT_PARAM_SPECIFY_MAP_TYPE = myCbTypeSpec.isSelected(); } GroovyApplicationSettings.getInstance().CONVERT_PARAM_CREATE_NEW_PARAM = myCreateNew.isSelected(); super.doOKAction(); }
doOKAction
29,122
JComponent () { return contentPane; }
createCenterPanel
29,123
JComponent () { return contentPane; }
getContentPane
29,124
String () { if (myNameComboBox.getEditor().getItem() instanceof String && !((String)myNameComboBox.getEditor().getItem()).isEmpty()) { return (String)myNameComboBox.getEditor().getItem(); } else { return null; } }
getEnteredName
29,125
void (@NlsSafe String[] possibleNames) { final EditorComboBoxEditor comboEditor = new StringComboboxEditor(myProject, GroovyFileType.GROOVY_FILE_TYPE, myNameComboBox); myNameComboBox.setEditor(comboEditor); myNameComboBox.setRenderer(new EditorComboBoxRenderer(comboEditor)); myNameComboBox.setEditable(true); myNameComboBox.setMaximumRowCount(8); myListenerList.add(DataChangedListener.class, new DataChangedListener()); myNameComboBox.addItemListener(new ItemListener() { @Override public void itemStateChanged(ItemEvent e) { fireNameDataChanged(); } }); ((EditorTextField)myNameComboBox.getEditor().getEditorComponent()).addDocumentListener(new DocumentListener() { @Override public void documentChanged(@NotNull DocumentEvent event) { fireNameDataChanged(); } }); contentPane.registerKeyboardAction(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { IdeFocusManager.getGlobalInstance().doWhenFocusSettlesDown(() -> IdeFocusManager.getGlobalInstance().requestFocus(myNameComboBox, true)); } }, KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.ALT_MASK), JComponent.WHEN_IN_FOCUSED_WINDOW); for (var possibleName : possibleNames) { myNameComboBox.addItem(possibleName); } }
setUpNameComboBox
29,126
void (ItemEvent e) { fireNameDataChanged(); }
itemStateChanged
29,127
void (@NotNull DocumentEvent event) { fireNameDataChanged(); }
documentChanged
29,128
void (ActionEvent e) { IdeFocusManager.getGlobalInstance().doWhenFocusSettlesDown(() -> IdeFocusManager.getGlobalInstance().requestFocus(myNameComboBox, true)); }
actionPerformed
29,129
void () { Object[] list = myListenerList.getListenerList(); for (Object aList : list) { if (aList instanceof DataChangedListener) { ((DataChangedListener)aList).dataChanged(); } } }
fireNameDataChanged
29,130
void () { String text = getEnteredName(); setOKActionEnabled(GroovyNamesUtil.isIdentifier(text)); }
updateOkStatus
29,131
boolean (PsiClass aClass) { return aClass.getLanguage() == GroovyLanguage.INSTANCE; }
isSupportedLanguage
29,132
void (PsiClass psiClass) { final CreateClassDialog dlg = chooseSubclassToCreate(psiClass); if (dlg != null) { createSubclassGroovy((GrTypeDefinition)psiClass, dlg.getTargetDirectory(), dlg.getClassName()); } }
createTopLevelClass
29,133
PsiClass (final GrTypeDefinition psiClass, final PsiDirectory targetDirectory, final String className) { final Project project = psiClass.getProject(); final Ref<GrTypeDefinition> targetClass = new Ref<>(); WriteCommandAction.writeCommandAction(project).withName(getTitle(psiClass)).withGroupId(getTitle(psiClass)).run(() -> { IdeDocumentHistory.getInstance(project).includeCurrentPlaceAsChangePlace(); final GrTypeParameterList oldTypeParameterList = psiClass.getTypeParameterList(); try { targetClass.set(CreateClassActionBase.createClassByType(targetDirectory, className, PsiManager.getInstance(project), psiClass, GroovyTemplates.GROOVY_CLASS, true)); } catch (final IncorrectOperationException e) { ApplicationManager.getApplication().invokeLater( () -> Messages.showErrorDialog(project, JavaBundle.message("intention.error.cannot.create.class.message", className) + "\n" + e.getLocalizedMessage(), JavaBundle.message("intention.error.cannot.create.class.title"))); return; } startTemplate(oldTypeParameterList, project, psiClass, targetClass.get(), false); }); if (targetClass.get() == null) return null; if (!ApplicationManager.getApplication().isUnitTestMode() && !psiClass.hasTypeParameters()) { final Editor editor = CodeInsightUtil.positionCursorAtLBrace(project, targetClass.get().getContainingFile(), targetClass.get()); if (editor == null) return targetClass.get(); chooseAndImplement(psiClass, project, targetClass.get(), editor); } return targetClass.get(); }
createSubclassGroovy
29,134
void (GrTypeParameterList oldTypeParameterList, final Project project, final GrTypeDefinition psiClass, final GrTypeDefinition targetClass, boolean includeClassName) { PsiElementFactory jfactory = JavaPsiFacade.getElementFactory(project); final GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(project); GrCodeReferenceElement stubRef = elementFactory.createCodeReferenceElementFromClass(psiClass); try { GrReferenceList clause = psiClass.isInterface() ? targetClass.getImplementsClause() : targetClass.getExtendsClause(); if (clause == null) { GrReferenceList stubRefList = psiClass.isInterface() ? elementFactory.createImplementsClause() : elementFactory.createExtendsClause(); clause = (GrExtendsClause)targetClass.addAfter(stubRefList, targetClass.getNameIdentifierGroovy()); } GrCodeReferenceElement ref = (GrCodeReferenceElement)clause.add(stubRef); if (psiClass.hasTypeParameters() || includeClassName) { final Editor editor = CodeInsightUtil.positionCursorAtLBrace(project, targetClass.getContainingFile(), targetClass); final TemplateBuilderImpl templateBuilder = editor == null || ApplicationManager.getApplication().isUnitTestMode() ? null : (TemplateBuilderImpl)TemplateBuilderFactory.getInstance().createTemplateBuilder(targetClass); if (includeClassName && templateBuilder != null) { templateBuilder.replaceElement(targetClass.getNameIdentifier(), targetClass.getName()); } if (oldTypeParameterList != null && oldTypeParameterList.getTypeParameters().length > 0) { GrTypeArgumentList existingList = ref.getTypeArgumentList(); final GrTypeParameterList typeParameterList = (GrTypeParameterList)targetClass.addAfter(elementFactory.createTypeParameterList(), targetClass.getNameIdentifierGroovy()); GrTypeArgumentList argList; if (existingList == null) { GrCodeReferenceElement codeRef = elementFactory.createCodeReference("A<T>"); argList = ((GrTypeArgumentList)ref.add(codeRef.getTypeArgumentList())); argList.getTypeArgumentElements()[0].delete(); } else { argList = existingList; } for (PsiTypeParameter parameter : oldTypeParameterList.getTypeParameters()) { final PsiElement param = argList.add(elementFactory.createTypeElement(jfactory.createType(parameter))); if (templateBuilder != null) { templateBuilder.replaceElement(param, param.getText()); } typeParameterList.add(elementFactory.createTypeParameter(parameter.getName(), parameter.getExtendsListTypes())); } } if (templateBuilder != null) { templateBuilder.setEndVariableBefore(ref); final Template template = templateBuilder.buildTemplate(); template.addEndVariable(); final PsiFile containingFile = targetClass.getContainingFile(); PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument()); final TextRange textRange = targetClass.getTextRange(); final RangeMarker startClassOffset = editor.getDocument().createRangeMarker(textRange.getStartOffset(), textRange.getEndOffset()); startClassOffset.setGreedyToLeft(true); startClassOffset.setGreedyToRight(true); editor.getDocument().deleteString(textRange.getStartOffset(), textRange.getEndOffset()); CreateFromUsageBaseFix.startTemplate(editor, template, project, new TemplateEditingAdapter() { @Override public void templateFinished(@NotNull Template template, boolean brokenOff) { chooseAndImplement(psiClass, project,PsiTreeUtil.getParentOfType(containingFile.findElementAt(startClassOffset.getStartOffset()), GrTypeDefinition.class),editor); } }, getTitle(psiClass)); } } } catch (IncorrectOperationException e) { LOG.error(e); } }
startTemplate
29,135
void (@NotNull Template template, boolean brokenOff) { chooseAndImplement(psiClass, project,PsiTreeUtil.getParentOfType(containingFile.findElementAt(startClassOffset.getStartOffset()), GrTypeDefinition.class),editor); }
templateFinished
29,136
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { PsiElement parent = element.getParent(); if (parent instanceof GrVariable) { ((GrVariable)parent).setType(null); } else if (parent instanceof GrVariableDeclaration) { ((GrVariableDeclaration)parent).setType(null); } else if (parent instanceof GrMethod) { ((GrMethod)parent).setReturnType(null); } }
processIntention
29,137
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { PsiElement parent = element.getParent(); if (element instanceof GrTypeElement || element instanceof GrModifierList) { return parent instanceof GrVariableDeclaration && ((GrVariableDeclaration)parent).getTypeElementGroovy() != null || parent instanceof GrMethod && ((GrMethod)parent).getReturnTypeElementGroovy() != null; } if (parent instanceof GrNamedElement && ((GrNamedElement)parent).getNameIdentifierGroovy().equals(element)) { if (parent instanceof GrVariable) { return ((GrVariable)parent).getTypeElementGroovy() != null; } if (parent instanceof GrMethod && ((GrMethod)parent).findSuperMethods().length == 0 ) { return ((GrMethod)parent).getReturnTypeElementGroovy() != null; } } return false; } }; }
getElementPredicate
29,138
boolean (@NotNull PsiElement element) { PsiElement parent = element.getParent(); if (element instanceof GrTypeElement || element instanceof GrModifierList) { return parent instanceof GrVariableDeclaration && ((GrVariableDeclaration)parent).getTypeElementGroovy() != null || parent instanceof GrMethod && ((GrMethod)parent).getReturnTypeElementGroovy() != null; } if (parent instanceof GrNamedElement && ((GrNamedElement)parent).getNameIdentifierGroovy().equals(element)) { if (parent instanceof GrVariable) { return ((GrVariable)parent).getTypeElementGroovy() != null; } if (parent instanceof GrMethod && ((GrMethod)parent).findSuperMethods().length == 0 ) { return ((GrMethod)parent).getReturnTypeElementGroovy() != null; } } return false; }
satisfiedBy
29,139
PsiElement (@NotNull PsiElement element) { if (isTargetVisible(element)) { return element; } PsiElement expression = PsiTreeUtil.getParentOfType(element, GrExpression.class); return expression == null ? null : getTargetExpression(expression); }
getTargetExpression
29,140
boolean (PsiElement element) { if (PsiUtil.isExpressionStatement(element) && element instanceof GrExpression) { if (!PsiTypes.voidType().equals(((GrExpression)element).getType())) { if (PsiTreeUtil.getParentOfType(element, GrAssignmentExpression.class) == null) { return true; } } } return false; }
isTargetVisible
29,141
void (Editor editor, PsiElement element) { int offset = element.getTextOffset(); int length = element.getTextLength(); editor.getSelectionModel().setSelection(offset, offset + length); }
setSelection
29,142
boolean () { return false; }
startInWriteAction
29,143
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { return getTargetExpression(element) != null; } }; }
getElementPredicate
29,144
boolean (@NotNull PsiElement element) { return getTargetExpression(element) != null; }
satisfiedBy
29,145
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { final PsiElement parent = element.getParent(); if (!(parent instanceof GrMember)) return; ((GrMember)parent).getModifierList().setModifierProperty(myModifier, true); }
processIntention
29,146
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { final PsiElement parent = element.getParent(); return parent instanceof GrMember && parent instanceof GrNamedElement && (((GrNamedElement)parent).getNameIdentifierGroovy() == element || ((GrMember)parent).getModifierList() == element) && ((GrMember)parent).getModifierList() != null && !((GrMember)parent).getModifierList().hasExplicitModifier(myModifier); } }; }
getElementPredicate
29,147
boolean (@NotNull PsiElement element) { final PsiElement parent = element.getParent(); return parent instanceof GrMember && parent instanceof GrNamedElement && (((GrNamedElement)parent).getNameIdentifierGroovy() == element || ((GrMember)parent).getModifierList() == element) && ((GrMember)parent).getModifierList() != null && !((GrMember)parent).getModifierList().hasExplicitModifier(myModifier); }
satisfiedBy
29,148
void (@NotNull Template template, boolean brokenOff) { if (brokenOff) { ApplicationManager.getApplication().runWriteAction(() -> { if (rangeMarker.isValid()) { document.replaceString(rangeMarker.getStartOffset(), rangeMarker.getEndOffset(), originalText); editor.getCaretModel().moveToOffset(rangeMarker.getStartOffset() + typeInfo.originalOffset); } }); } }
templateFinished
29,149
PsiType (@NotNull PsiParameter parameter) { final PsiElement scope = parameter.getDeclarationScope(); final PsiType type; if (scope instanceof GrClosableBlock) { type = ClosureParameterEnhancer.inferType((GrClosableBlock)scope, ((GrParameterList)parameter.getParent()).getParameterIndex(parameter)); } else { type = null; } return type; }
getClosureParameterType
29,150
TypeInfo (@NotNull PsiElement parent, @NotNull PsiElement elementToBuildTemplateOn) { GrModifierList modifierList = getModifierList(parent); if (modifierList != null && modifierList.hasModifierProperty(GrModifier.DEF) && modifierList.getModifiers().length == 1) { PsiElement modifier = modifierList.getModifier(GrModifier.DEF); LOG.assertTrue(modifier != null); int modifierOffset = modifier.getTextRange().getEndOffset() - elementToBuildTemplateOn.getTextRange().getStartOffset(); return new TypeInfo(modifier, modifierOffset); } else { int nameElementOffset; final PsiClassType typeToUse = TypesUtil.createType("Abc", parent); if (elementToBuildTemplateOn instanceof GrVariableDeclaration decl) { decl.setType(typeToUse); nameElementOffset = decl.getModifierList().getTextRange().getEndOffset() - elementToBuildTemplateOn.getTextRange().getStartOffset(); } else { GrVariable var = (GrVariable)parent; var.setType(typeToUse); nameElementOffset = var.getNameIdentifierGroovy().getTextRange().getStartOffset() - elementToBuildTemplateOn.getTextRange().getStartOffset(); } return new TypeInfo(getTypeElement(parent), nameElementOffset); } }
getOrCreateTypeElement
29,151
GrTypeElement (PsiElement parent) { if (parent instanceof GrVariable) { return ((GrVariable)parent).getTypeElementGroovy(); } else { return ((GrVariableDeclaration)parent).getTypeElementGroovy(); } }
getTypeElement
29,152
GrModifierList (PsiElement parent) { GrModifierList modifierList; if (parent instanceof GrVariable) { modifierList = ((GrVariable)parent).getModifierList(); } else { modifierList = ((GrVariableDeclaration)parent).getModifierList(); } return modifierList; }
getModifierList
29,153
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { PsiElement parent = element.getParent(); PsiElement pparent; if (isNameIdentifierOfVariable(element, parent) || isModifierListOfVar(element, parent)) { pparent = parent.getParent(); } else if (isModifierListOfVarDecl(element, parent)) { pparent = parent; } else { return false; } if (pparent instanceof GrVariableDeclaration) { if (((GrVariableDeclaration)pparent).getTypeElementGroovy() != null) return false; GrVariable[] variables = ((GrVariableDeclaration)pparent).getVariables(); for (GrVariable variable : variables) { if (isVarDeclaredWithInitializer(variable)) return true; } } else if (pparent instanceof GrForInClause) { final GrVariable variable = ((GrForInClause)pparent).getDeclaredVariable(); return variable != null && variable.getTypeElementGroovy() == null && PsiUtil.extractIteratedType((GrForInClause)pparent) != null; } else if (parent instanceof GrParameter && pparent instanceof GrParameterList) { return ((GrParameter)parent).getTypeElementGroovy() == null && getClosureParameterType((PsiParameter)parent) != null; } else { final GrVariable variable = (GrVariable)parent; return variable.getTypeElementGroovy() == null && isVarDeclaredWithInitializer(variable); } return false; } private static boolean isModifierListOfVarDecl(PsiElement element, PsiElement parent) { return parent instanceof GrVariableDeclaration && ((GrVariableDeclaration)parent).getModifierList() == element; } private static boolean isModifierListOfVar(PsiElement element, PsiElement parent) { return parent instanceof GrVariable && ((GrVariable)parent).getModifierList() == element; } private static boolean isNameIdentifierOfVariable(PsiElement element, PsiElement parent) { return parent instanceof GrVariable && ((GrVariable)parent).getTypeElementGroovy() == null && element == ((GrVariable)parent).getNameIdentifierGroovy(); } }; }
getElementPredicate
29,154
boolean (@NotNull PsiElement element) { PsiElement parent = element.getParent(); PsiElement pparent; if (isNameIdentifierOfVariable(element, parent) || isModifierListOfVar(element, parent)) { pparent = parent.getParent(); } else if (isModifierListOfVarDecl(element, parent)) { pparent = parent; } else { return false; } if (pparent instanceof GrVariableDeclaration) { if (((GrVariableDeclaration)pparent).getTypeElementGroovy() != null) return false; GrVariable[] variables = ((GrVariableDeclaration)pparent).getVariables(); for (GrVariable variable : variables) { if (isVarDeclaredWithInitializer(variable)) return true; } } else if (pparent instanceof GrForInClause) { final GrVariable variable = ((GrForInClause)pparent).getDeclaredVariable(); return variable != null && variable.getTypeElementGroovy() == null && PsiUtil.extractIteratedType((GrForInClause)pparent) != null; } else if (parent instanceof GrParameter && pparent instanceof GrParameterList) { return ((GrParameter)parent).getTypeElementGroovy() == null && getClosureParameterType((PsiParameter)parent) != null; } else { final GrVariable variable = (GrVariable)parent; return variable.getTypeElementGroovy() == null && isVarDeclaredWithInitializer(variable); } return false; }
satisfiedBy
29,155
boolean (PsiElement element, PsiElement parent) { return parent instanceof GrVariableDeclaration && ((GrVariableDeclaration)parent).getModifierList() == element; }
isModifierListOfVarDecl
29,156
boolean (PsiElement element, PsiElement parent) { return parent instanceof GrVariable && ((GrVariable)parent).getModifierList() == element; }
isModifierListOfVar
29,157
boolean (PsiElement element, PsiElement parent) { return parent instanceof GrVariable && ((GrVariable)parent).getTypeElementGroovy() == null && element == ((GrVariable)parent).getNameIdentifierGroovy(); }
isNameIdentifierOfVariable
29,158
boolean (GrVariable variable) { GrExpression initializer = variable.getInitializerGroovy(); return initializer != null && initializer.getType() != null; }
isVarDeclaredWithInitializer
29,159
boolean (@NotNull PsiParameter parameter) { PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof GrMethod)) return false; if (((GrMethod)scope).getContainingClass() == null) return false; if (checkAssignmentToFieldExists(parameter)) return false; return true; }
isAvailable
29,160
PsiType (@NotNull PsiParameter parameter) { return GroovyRefactoringUtil.getSubstitutedType((GrParameter)parameter); }
getSubstitutedType
29,161
boolean (PsiParameter parameter) { for (PsiReference reference : ReferencesSearch.search(parameter).findAll()) { PsiElement element = reference.getElement(); if (element instanceof GrReferenceExpression && element.getParent() instanceof GrAssignmentExpression parent && ((GrAssignmentExpression)element.getParent()).getRValue() == element) { GrExpression value = parent.getLValue(); if (value instanceof GrReferenceExpression && ((GrReferenceExpression)value).resolve() instanceof PsiField) return true; } } return false; }
checkAssignmentToFieldExists
29,162
PsiVariable (@NotNull Project project, @NotNull PsiClass targetClass, @NotNull PsiMethod method, @NotNull PsiParameter myParameter, PsiType type, @NotNull String fieldName, boolean methodStatic, boolean isFinal) { GrOpenBlock block = ((GrMethod)method).getBlock(); if (block == null) return null; GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(project); GrAssignmentExpression assignment = createAssignment(targetClass, myParameter, fieldName, methodStatic, factory); GrStatement anchor = getAnchor(block); GrStatement statement = block.addStatementBefore(assignment, anchor); JavaCodeStyleManager.getInstance(project).shortenClassReferences(statement); if (targetClass.findFieldByName(fieldName, false) == null) { String[] modifiers = getModifiers(methodStatic, isFinal); GrVariableDeclaration fieldDeclaration = factory.createFieldDeclaration(modifiers, fieldName, null, type); GrVariableDeclaration inserted = (GrVariableDeclaration)targetClass.add(fieldDeclaration); JavaCodeStyleManager.getInstance(project).shortenClassReferences(inserted); return inserted.getVariables()[0]; } return null; }
createField
29,163
GrAssignmentExpression (PsiClass targetClass, PsiParameter myParameter, String fieldName, boolean methodStatic, GroovyPsiElementFactory factory) { StringBuilder builder = new StringBuilder(); if (methodStatic) { builder.append(targetClass.getQualifiedName()); builder.append('.'); } else { builder.append("this."); } builder.append(fieldName); builder.append("=").append(myParameter.getName()); return (GrAssignmentExpression)factory.createStatementFromText(builder.toString()); }
createAssignment
29,164
GrStatement (GrOpenBlock block) { GrStatement[] statements = block.getStatements(); GrStatement fist = ArrayUtil.getFirstElement(statements); if (fist instanceof GrConstructorInvocation) { return statements.length > 1 ? statements[1] : null; } else { return fist; } }
getAnchor
29,165
String[] (boolean aStatic, boolean aFinal) { List<String> list = new ArrayList<>(); list.add(PsiModifier.PRIVATE); if (aStatic) list.add(PsiModifier.STATIC); if (aFinal) list.add(PsiModifier.FINAL); return ArrayUtilRt.toStringArray(list); }
getModifiers
29,166
void (@NotNull Project project, @NotNull GrImportStatement importStatement, @NotNull PsiMember member) { if (member instanceof GrAccessorMethod && !importStatement.isOnDemand() && !Objects.equals(importStatement.getImportedName(), member.getName())) { member = ((GrAccessorMethod)member).getProperty(); } final GroovyFileBase file = (GroovyFileBase)importStatement.getContainingFile(); final List<UsageInfo> usages = findUsages(member, file); GrImportStatement templateImport = createTemplateImport(project, member, file); if (ApplicationManager.getApplication().isUnitTestMode()) { if (!importStatement.isOnDemand()) { importStatement.delete(); } updateRefs(usages, member.getName(), templateImport); } else { runTemplate(project, importStatement, member, file, usages, templateImport); } }
doRefactoring
29,167
GrImportStatement (Project project, PsiMember resolved, GroovyFileBase file) { final PsiClass aClass = resolved.getContainingClass(); assert aClass != null; String qname = aClass.getQualifiedName(); final String name = resolved.getName(); GrImportStatement template = GroovyPsiElementFactory.getInstance(project) .createImportStatementFromText("import static " + qname + "." + name + " as aliased"); return file.addImport(template); }
createTemplateImport
29,168
void (Project project, final GrImportStatement context, PsiMember resolved, final GroovyFileBase file, final List<UsageInfo> usages, GrImportStatement templateImport) { PostprocessReformattingAspect.getInstance(project).doPostponedFormatting(); TemplateBuilderImpl templateBuilder = new TemplateBuilderImpl(templateImport); LinkedHashSet<String> names = getSuggestedNames(resolved, context); final GrImportAlias alias = templateImport.getAlias(); assert alias != null; final PsiElement aliasNameElement = alias.getNameElement(); assert aliasNameElement != null; MyLookupExpression lookupExpression = new MyLookupExpression(resolved.getName(), names, (PsiNamedElement)resolved, resolved, true, null); lookupExpression.setLookupFocusDegree(LookupFocusDegree.UNFOCUSED); templateBuilder.replaceElement(aliasNameElement, lookupExpression); Template built = templateBuilder.buildTemplate(); final Editor newEditor = IntentionUtils.positionCursor(project, file, templateImport); final Document document = newEditor.getDocument(); final RangeMarker contextImportPointer = document.createRangeMarker(context.getTextRange()); final TextRange range = templateImport.getTextRange(); document.deleteString(range.getStartOffset(), range.getEndOffset()); final String name = resolved.getName(); TemplateManager manager = TemplateManager.getInstance(project); manager.startTemplate(newEditor, built, new TemplateEditingAdapter() { @Override public void templateFinished(@NotNull Template template, boolean brokenOff) { final GrImportStatement importStatement = ReadAction .compute(() -> PsiTreeUtil.findElementOfClassAtOffset(file, range.getStartOffset(), GrImportStatement.class, true)); if (brokenOff) { if (importStatement != null) { ApplicationManager.getApplication().runWriteAction(() -> importStatement.delete()); } return; } updateRefs(usages, name, importStatement); ApplicationManager.getApplication().runWriteAction(() -> { final GrImportStatement context1 = PsiTreeUtil.findElementOfClassAtRange(file, contextImportPointer.getStartOffset(), contextImportPointer.getEndOffset(), GrImportStatement.class); if (context1 != null) { context1.delete(); } }); } }); }
runTemplate
29,169
void (@NotNull Template template, boolean brokenOff) { final GrImportStatement importStatement = ReadAction .compute(() -> PsiTreeUtil.findElementOfClassAtOffset(file, range.getStartOffset(), GrImportStatement.class, true)); if (brokenOff) { if (importStatement != null) { ApplicationManager.getApplication().runWriteAction(() -> importStatement.delete()); } return; } updateRefs(usages, name, importStatement); ApplicationManager.getApplication().runWriteAction(() -> { final GrImportStatement context1 = PsiTreeUtil.findElementOfClassAtRange(file, contextImportPointer.getStartOffset(), contextImportPointer.getEndOffset(), GrImportStatement.class); if (context1 != null) { context1.delete(); } }); }
templateFinished
29,170
void (List<UsageInfo> usages, final String memberName, final GrImportStatement updatedImport) { if (updatedImport == null) return; final String name = ReadAction.compute(() -> updatedImport.getImportedName()); for (final UsageInfo usage : usages) { ApplicationManager.getApplication().runWriteAction(() -> { final PsiElement usageElement = usage.getElement(); if (usageElement == null) return; if (usageElement.getParent() instanceof GrImportStatement) return; if (usageElement instanceof GrReferenceElement ref) { final PsiElement qualifier = ref.getQualifier(); if (qualifier == null) { final String refName = ref.getReferenceName(); if (refName == null) return; if (memberName.equals(refName)) { ref.handleElementRename(name); } else if (refName.equals(GroovyPropertyUtils.getPropertyNameByAccessorName(memberName))) { final String newPropName = GroovyPropertyUtils.getPropertyNameByAccessorName(name); if (newPropName != null) { ref.handleElementRename(newPropName); } else { ref.handleElementRename(name); } } else if (refName.equals(GroovyPropertyUtils.getGetterNameBoolean(memberName))) { final String getterName = GroovyPropertyUtils.getGetterNameBoolean(name); ref.handleElementRename(getterName); } else if (refName.equals(GroovyPropertyUtils.getGetterNameNonBoolean(memberName))) { final String getterName = GroovyPropertyUtils.getGetterNameNonBoolean(name); ref.handleElementRename(getterName); } else if (refName.equals(GroovyPropertyUtils.getSetterName(memberName))) { final String getterName = GroovyPropertyUtils.getSetterName(name); ref.handleElementRename(getterName); } } } }); } }
updateRefs
29,171
List<UsageInfo> (PsiMember member, GroovyFileBase file) { LocalSearchScope scope = new LocalSearchScope(file); final ArrayList<UsageInfo> infos = new ArrayList<>(); final HashSet<Object> usedRefs = new HashSet<>(); final Processor<PsiReference> consumer = reference -> { if (usedRefs.add(reference)) { infos.add(new UsageInfo(reference)); } return true; }; if (member instanceof PsiMethod) { MethodReferencesSearch.search((PsiMethod)member, scope, false).forEach(consumer); } else { ReferencesSearch.search(member, scope).forEach(consumer); if (member instanceof PsiField) { final PsiMethod getter = GroovyPropertyUtils.findGetterForField((PsiField)member); if (getter != null) { MethodReferencesSearch.search(getter, scope, false).forEach(consumer); } final PsiMethod setter = GroovyPropertyUtils.findSetterForField((PsiField)member); if (setter != null) { MethodReferencesSearch.search(setter, scope, false).forEach(consumer); } } } return infos; }
findUsages
29,172
LinkedHashSet<String> (PsiElement psiElement, final PsiElement nameSuggestionContext) { final LinkedHashSet<String> result = new LinkedHashSet<>(); result.add(UsageViewUtil.getShortName(psiElement)); NameSuggestionProvider.suggestNames(psiElement, nameSuggestionContext, result); return result; }
getSuggestedNames
29,173
PsiElementPredicate () { return AliasImportIntentionPredicate.INSTANCE; }
getElementPredicate
29,174
boolean (@NotNull GrExpression element, @NotNull ActionContext context) { if (element instanceof GrLiteral literal && literal.getValue() instanceof String) return true; if (!(element instanceof GrBinaryExpression binOp)) return false; if (binOp.getOperationTokenType() != GroovyTokenTypes.mPLUS) return false; var left = binOp.getLeftOperand(); var right = binOp.getRightOperand(); return right != null && isElementApplicable(left, context) && isElementApplicable(right, context); }
isElementApplicable
29,175
ModCommand (@NotNull ActionContext context, @NotNull GrExpression element) { final StringBuilder buffer = new StringBuilder(); getValue(element, buffer); return new ModCopyToClipboard(buffer.toString()); }
perform
29,176
String () { return GroovyIntentionsBundle.message("gr.copy.string.concatenation.content.intention.family.name"); }
getFamilyName
29,177
void (PsiElement element, StringBuilder buffer) { if (element instanceof GrLiteral literal) { buffer.append(literal.getValue()); } else if (element instanceof GrBinaryExpression binOp) { getValue(binOp.getLeftOperand(), buffer); getValue(binOp.getRightOperand(), buffer); } }
getValue
29,178
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { if (!(element instanceof GrSwitchStatement)) return; final List<PsiEnumConstant> constants = findUnusedConstants((GrSwitchStatement)element); if (constants.isEmpty()) return; final PsiEnumConstant first = constants.get(0); final PsiClass aClass = first.getContainingClass(); if (aClass == null) return; String qName = aClass.getQualifiedName(); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(context.project()); PsiElement anchor = findAnchor(element); for (PsiEnumConstant constant : constants) { final GrCaseSection section = factory.createSwitchSection("case " + qName + "." + constant.getName() + ":\n break"); final PsiElement added = element.addBefore(section, anchor); JavaCodeStyleManager.getInstance(context.project()).shortenClassReferences(added); } }
processIntention
29,179
PsiElement (PsiElement element) { final PsiElement last = element.getLastChild(); if (last != null && last.getNode().getElementType() == GroovyTokenTypes.mRCURLY) return last; return null; }
findAnchor
29,180
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { if (!(element instanceof GrSwitchStatement)) return false; final List<PsiEnumConstant> unused = findUnusedConstants((GrSwitchStatement)element); return !unused.isEmpty(); } }; }
getElementPredicate
29,181
boolean (@NotNull PsiElement element) { if (!(element instanceof GrSwitchStatement)) return false; final List<PsiEnumConstant> unused = findUnusedConstants((GrSwitchStatement)element); return !unused.isEmpty(); }
satisfiedBy
29,182
List<PsiEnumConstant> (GrSwitchStatement switchStatement) { final GrExpression condition = switchStatement.getCondition(); if (condition == null) return Collections.emptyList(); final PsiType type = condition.getType(); if (!(type instanceof PsiClassType)) return Collections.emptyList(); final PsiClass resolved = ((PsiClassType)type).resolve(); if (resolved == null || !resolved.isEnum()) return Collections.emptyList(); final PsiField[] fields = resolved.getFields(); final List<PsiEnumConstant> constants = new ArrayList<>(ContainerUtil.findAll(fields, PsiEnumConstant.class)); final GrCaseSection[] sections = switchStatement.getCaseSections(); for (GrCaseSection section : sections) { for (GrExpression value : section.getExpressions()) { if (value instanceof GrReferenceExpression) { final PsiElement r = ((GrReferenceExpression)value).resolve(); constants.remove(r); } } } return constants; }
findUnusedConstants
29,183
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { PsiElement parent = element.getParent(); if (parent instanceof GrArgumentLabel) { PsiElement pparent = parent.getParent().getParent(); if (pparent instanceof GrListOrMap map && !ErrorUtil.containsError(pparent)) { if (map.getInitializers().length == 0) { GrNamedArgument[] namedArgs = map.getNamedArguments(); if (isLiteralKeys(namedArgs)) { GrListOrMap newMap = constructNewMap(namedArgs, context.project()); map.replace(newMap); } } } } }
processIntention
29,184
GrListOrMap (GrNamedArgument @NotNull [] args, Project project) { StringBuilder builder = new StringBuilder(); builder.append("["); Arrays.sort(args, (o1, o2) -> { final String l1 = o1.getLabelName(); final String l2 = o2.getLabelName(); assert l1 != null && l2 != null; return l1.compareTo(l2); }); for (GrNamedArgument arg : args) { builder.append(arg.getText()).append(",\n"); } builder.replace(builder.length() - 2, builder.length(), "]"); return (GrListOrMap)GroovyPsiElementFactory.getInstance(project).createExpressionFromText(builder); }
constructNewMap
29,185
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { final PsiElement parent = element.getParent(); if (!(parent instanceof GrArgumentLabel)) return false; if (((GrArgumentLabel)parent).getNameElement() != element) return false; final PsiElement grandParent = parent.getParent(); if (grandParent == null) return false; final PsiElement grandGrandParent = grandParent.getParent(); if (!(grandGrandParent instanceof GrListOrMap map)) return false; return !ErrorUtil.containsError(map) && map.getInitializers().length == 0 && isLiteralKeys(map.getNamedArguments()); } }; }
getElementPredicate
29,186
boolean (@NotNull PsiElement element) { final PsiElement parent = element.getParent(); if (!(parent instanceof GrArgumentLabel)) return false; if (((GrArgumentLabel)parent).getNameElement() != element) return false; final PsiElement grandParent = parent.getParent(); if (grandParent == null) return false; final PsiElement grandGrandParent = grandParent.getParent(); if (!(grandGrandParent instanceof GrListOrMap map)) return false; return !ErrorUtil.containsError(map) && map.getInitializers().length == 0 && isLiteralKeys(map.getNamedArguments()); }
satisfiedBy
29,187
boolean (GrNamedArgument[] args) { return ContainerUtil.and(args, it -> it.getLabel() != null); }
isLiteralKeys
29,188
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { GrMethod method = (GrMethod)element.getParent(); GrOpenBlock block = method.getBlock(); if (block == null) return; GrStatement statement = block.getStatements()[0]; GrExpression value; if (statement instanceof GrReturnStatement) { value = ((GrReturnStatement)statement).getReturnValue(); } else { value = (GrExpression)statement; } String fieldName = GroovyPropertyUtils.getPropertyNameByGetter(method); if (fieldName == null) return; PsiClass aClass = method.getContainingClass(); if (aClass == null) return; List<String> modifiers = new ArrayList<>(); for (String modifier : MODIFIERS_TO_CHECK) { if (method.hasModifierProperty(modifier)) modifiers.add(modifier); } modifiers.add(PsiModifier.FINAL); GrTypeElement returnTypeElement = method.getReturnTypeElementGroovy(); PsiType returnType = returnTypeElement == null ? null : returnTypeElement.getType(); GrVariableDeclaration declaration = GroovyPsiElementFactory.getInstance(context.project()).createFieldDeclaration( ArrayUtilRt.toStringArray(modifiers), fieldName, value, returnType ); PsiElement replaced = method.replace(declaration); JavaCodeStyleManager.getInstance(context.project()).shortenClassReferences(replaced); }
processIntention
29,189
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod method) || ((GrMethod)parent).getNameIdentifierGroovy() != element) return false; GrOpenBlock block = method.getBlock(); if (block == null) return false; GrStatement[] statements = block.getStatements(); if (statements.length != 1) return false; if (!GroovyPropertyUtils.isSimplePropertyGetter(method)) return false; if (GroovyPropertyUtils.findFieldForAccessor(method, true) != null) return false; GrStatement statement = statements[0]; if (!(statement instanceof GrReturnStatement && ((GrReturnStatement)statement).getReturnValue() != null || statement instanceof GrExpression && !PsiTypes.voidType().equals(((GrExpression)statement).getType()))) { return false; } return true; } }; }
getElementPredicate
29,190
boolean (@NotNull PsiElement element) { PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod method) || ((GrMethod)parent).getNameIdentifierGroovy() != element) return false; GrOpenBlock block = method.getBlock(); if (block == null) return false; GrStatement[] statements = block.getStatements(); if (statements.length != 1) return false; if (!GroovyPropertyUtils.isSimplePropertyGetter(method)) return false; if (GroovyPropertyUtils.findFieldForAccessor(method, true) != null) return false; GrStatement statement = statements[0]; if (!(statement instanceof GrReturnStatement && ((GrReturnStatement)statement).getReturnValue() != null || statement instanceof GrExpression && !PsiTypes.voidType().equals(((GrExpression)statement).getType()))) { return false; } return true; }
satisfiedBy
29,191
PsiElementPredicate () { return new MyPredicate(); }
getElementPredicate
29,192
void (final GrMethod method, final Collection<GrReferenceExpression> usagesToConvert) { GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(method.getProject()); StringBuilder builder = new StringBuilder(method.getTextLength()); String modifiers = method.getModifierList().getText(); if (modifiers.trim().isEmpty()) { modifiers = GrModifier.DEF; } builder.append(modifiers).append(' '); builder.append(method.getName()).append("={"); GrParameterList parameterList = method.getParameterList(); builder.append(parameterList.getParametersRange().shiftLeft( parameterList.getTextRange().getStartOffset() ).subSequence( parameterList.getText() )); builder.append(" ->"); final GrOpenBlock block = method.getBlock(); builder.append(block.getText().substring(1)); final GrVariableDeclaration variableDeclaration = GroovyPsiElementFactory.getInstance(method.getProject()).createFieldDeclarationFromText(builder.toString()); method.replace(variableDeclaration); for (GrReferenceExpression element : usagesToConvert) { final PsiElement qualifier = element.getQualifier(); final StringBuilder text = new StringBuilder(qualifier.getText()); element.setQualifier(null); text.append('.').append(element.getText()); element.replace(factory.createExpressionFromText(text.toString())); } } private static class MyPredicate implements PsiElementPredicate { @Override public boolean satisfiedBy(@NotNull PsiElement element) { if (element.getLanguage() != GroovyLanguage.INSTANCE) return false; GrMethod method; final PsiReference ref = element.getReference(); if (ref != null) { final PsiElement resolved = ref.resolve(); if (!(resolved instanceof GrMethod)) return false; method = (GrMethod)resolved; } else { final PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod)) return false; if (((GrMethod)parent).getNameIdentifierGroovy() != element) return false; method = (GrMethod)parent; } return !method.isConstructor() && isJavaIdentifier(method.getName()) && method.hasBlock() && method.getParent() instanceof GrTypeDefinitionBody; } } }
execute
29,193
boolean (@NotNull PsiElement element) { if (element.getLanguage() != GroovyLanguage.INSTANCE) return false; GrMethod method; final PsiReference ref = element.getReference(); if (ref != null) { final PsiElement resolved = ref.resolve(); if (!(resolved instanceof GrMethod)) return false; method = (GrMethod)resolved; } else { final PsiElement parent = element.getParent(); if (!(parent instanceof GrMethod)) return false; if (((GrMethod)parent).getNameIdentifierGroovy() != element) return false; method = (GrMethod)parent; } return !method.isConstructor() && isJavaIdentifier(method.getName()) && method.hasBlock() && method.getParent() instanceof GrTypeDefinitionBody; }
satisfiedBy
29,194
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { if (!(element instanceof GrTypeCastExpression)) return; GrExpression operand = ((GrTypeCastExpression)element).getOperand(); GrTypeElement type = ((GrTypeCastExpression)element).getCastTypeElement(); if (type == null) return; if (operand == null) return; GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(context.project()); GrExpression safeCast = factory.createExpressionFromText(operand.getText() + " as " + type.getText()); ((GrTypeCastExpression)element).replaceWithExpression(safeCast, true); }
processIntention
29,195
PsiElementPredicate () { return new PsiElementPredicate() { @Override public boolean satisfiedBy(@NotNull PsiElement element) { return element instanceof GrTypeCastExpression && ((GrTypeCastExpression)element).getCastTypeElement() != null && ((GrTypeCastExpression)element).getOperand() != null; } }; }
getElementPredicate
29,196
boolean (@NotNull PsiElement element) { return element instanceof GrTypeCastExpression && ((GrTypeCastExpression)element).getCastTypeElement() != null && ((GrTypeCastExpression)element).getOperand() != null; }
satisfiedBy
29,197
PsiElementPredicate () { return new ConvertIntegerToDecimalPredicate(); }
getElementPredicate
29,198
void (@NotNull PsiElement element, @NotNull ActionContext context, @NotNull ModPsiUpdater updater) { final GrLiteral exp = (GrLiteral)element; @NonNls String textString = exp.getText().replaceAll("_", ""); final int textLength = textString.length(); final char lastChar = textString.charAt(textLength - 1); final boolean isLong = lastChar == 'l' || lastChar == 'L'; if (isLong) { textString = textString.substring(0, textLength - 1); } final BigInteger val; if (textString.startsWith("0x") || textString.startsWith("0X")) { final String rawIntString = textString.substring(2); val = new BigInteger(rawIntString, 16); } else if (textString.startsWith("0b") || textString.startsWith("0B")) { final String rawString = textString.substring(2); val = new BigInteger(rawString, 2); } else { final String rawIntString = textString.substring(1); val = new BigInteger(rawIntString, 8); } String decimalString = val.toString(10); if (isLong) { decimalString += 'L'; } PsiImplUtil.replaceExpression(decimalString, exp); }
processIntention
29,199
boolean (@NotNull PsiElement element) { if (!(element instanceof GrMethodCallExpression callExpression)) { return false; } if (ErrorUtil.containsError(element)) { return false; } final GrArgumentList argList = callExpression.getArgumentList(); final GrExpression[] arguments = argList.getExpressionArguments(); final GrExpression invokedExpression = callExpression.getInvokedExpression(); if (!(invokedExpression instanceof GrReferenceExpression referenceExpression)) { return false; } final GrExpression qualifier = referenceExpression.getQualifierExpression(); if (qualifier == null) { return false; } final IElementType referenceType = referenceExpression.getDotTokenType(); if (!GroovyTokenTypes.mDOT.equals(referenceType)) { return false; } final String methodName = referenceExpression.getReferenceName(); if ("getAt".equals(methodName)) { return arguments.length == 1; } if ("get".equals(methodName)) { final PsiType qualifierType = qualifier.getType(); if (!isMap(qualifierType)) { return false; } return arguments.length == 1; } else if ("setAt".equals(methodName)) { return arguments.length == 2; } else if ("put".equals(methodName)) { final PsiType qualifierType = qualifier.getType(); if (!isMap(qualifierType)) { return false; } return arguments.length == 2; } return false; }
satisfiedBy