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
31,500
void (Project project, Editor editor, PsiElement element) { final Pair<List<? extends PsiElement>, String> pair = RenamePropertyUtil.askToRenameProperty((PsiMember)element); final List<? extends PsiElement> result = pair.getFirst(); if (result.isEmpty()) return; PsiElement propertyToRename = getPropertyToRename(element, result, pair.getSecond()); PsiElementRenameHandler.invoke(propertyToRename, project, element, editor); }
invokeInner
31,501
PsiElement (PsiElement element, List<? extends PsiElement> result, String propertyName) { if (result.size() == 1) { return result.get(0); } else /*if (result.size() > 1)*/ { return new PropertyForRename(result, propertyName, element.getManager()); } }
getPropertyToRename
31,502
String () { return GroovyRefactoringBundle.message("rename.groovy.property"); }
getActionTitle
31,503
boolean (@NotNull PsiElement element) { return element instanceof GroovyFile && ((GroovyFile)element).isScript() && GroovyScriptUtil.isPlainGroovyScript((GroovyFile)element); }
canProcessElement
31,504
void (@NotNull PsiElement element, @NotNull String newName, @NotNull Map<PsiElement, String> allRenames) { if (element instanceof GroovyFile) { final PsiClass script = ((GroovyFile)element).getScriptClass(); if (script != null && script.isValid()) { final String scriptName = FileUtilRt.getNameWithoutExtension(newName); if (StringUtil.isJavaIdentifier(scriptName)) { allRenames.put(script, scriptName); } } } }
prepareRenaming
31,505
void (@NotNull PsiElement element, @NotNull String newName, @NotNull MultiMap<PsiElement, String> conflicts) { final String scriptName = FileUtilRt.getNameWithoutExtension(newName); if (!StringUtil.isJavaIdentifier(scriptName)) { final PsiClass script = ((GroovyFile)element).getScriptClass(); conflicts.putValue(script, GroovyRefactoringBundle.message("cannot.rename.script.class.to.0", script.getName(), scriptName)); } }
findExistingNameConflicts
31,506
boolean (@NotNull PsiElement element) { return element instanceof GroovyPsiElement && super.canProcessElement(element); }
canProcessElement
31,507
Collection<PsiReference> (@NotNull PsiElement element, @NotNull SearchScope searchScope, boolean searchInCommentsAndStrings) { return RenameAliasedUsagesUtil.filterAliasedRefs(super.findReferences(element, searchScope, searchInCommentsAndStrings), element); }
findReferences
31,508
RenameDialog (@NotNull Project project, @NotNull PsiElement element, PsiElement nameSuggestionContext, Editor editor) { return new RenameDialog(project, element, nameSuggestionContext, editor) { @Override protected boolean areButtonsValid() { return true; } }; }
createRenameDialog
31,509
boolean () { return true; }
areButtonsValid
31,510
void (@NotNull PsiElement element, @NotNull final String newName, @NotNull final Map<? extends PsiElement, String> allRenames, @NotNull final List<UsageInfo> result) { if (element instanceof PsiMethod method) { OverridingMethodsSearch.search(method).forEach(overrider -> { PsiElement original = overrider; if (overrider instanceof PsiMirrorElement) { original = ((PsiMirrorElement)overrider).getPrototype(); } if (original instanceof SyntheticElement) return true; if (original instanceof GrField) { result.add(new FieldNameCollisionInfo((GrField)original, method)); } return true; }); } final ListIterator<UsageInfo> iterator = result.listIterator(); while (iterator.hasNext()) { final UsageInfo info = iterator.next(); final PsiElement ref = info.getElement(); if (ref instanceof GrReferenceExpression || ref == null) continue; if (!RenameUtil.isValidName(element.getProject(), ref, newName)) { iterator.add(new UnresolvableCollisionUsageInfo(ref, element) { @Override public String getDescription() { return RefactoringBundle.message("0.is.not.an.identifier", newName, ref.getText()); } }); } } }
findCollisions
31,511
String () { return RefactoringBundle.message("0.is.not.an.identifier", newName, ref.getText()); }
getDescription
31,512
PsiElement (PsiReference ref, String newName) { PsiElement element = ref.getElement(); if (RenameUtil.isValidName(element.getProject(), element, newName) || element instanceof GrReferenceElement) { return super.processRef(ref, newName); } PsiElement nameElement; if (element instanceof PsiReferenceExpression) { nameElement = ((PsiReferenceExpression)element).getReferenceNameElement(); } else { return null; } TextRange range = nameElement.getTextRange(); Document document = PsiDocumentManager.getInstance(element.getProject()).getDocument(nameElement.getContainingFile()); document.replaceString(range.getStartOffset(), range.getEndOffset(), newName); return null; }
processRef
31,513
String () { return GroovyRefactoringBundle.message("cannot.rename.property.0", myName, myBaseName); }
getDescription
31,514
void (String newName) { PsiNamedElement elementToRename = getVariable(); if (elementToRename instanceof ClosureSyntheticParameter && !"it".equals(newName)) { final GrClosableBlock closure = ((ClosureSyntheticParameter)elementToRename).getClosure(); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myProject); final PsiType type = ((ClosureSyntheticParameter)elementToRename).getTypeGroovy(); final GrParameter newParam = factory.createParameter(newName, TypesUtil.unboxPrimitiveTypeWrapper(type)); final GrParameter added = closure.addParameter(newParam); JavaCodeStyleManager.getInstance(added.getProject()).shortenClassReferences(added); } }
renameSynthetic
31,515
boolean (String newName, Language language) { return true; }
isIdentifier
31,516
TextRange (@NotNull PsiElement element) { TextRange range = getIdentifierNameRange(element); return range != null ? range : super.getRangeToRename(element); }
getRangeToRename
31,517
TextRange (@NotNull PsiReference reference) { TextRange range = getReferenceNameRange(reference.getElement()); return range != null ? range : super.getRangeToRename(reference); }
getRangeToRename
31,518
TextRange (@NotNull PsiElement element) { if (element instanceof JavaIdentifier) { return GrStringUtil.getStringContentRange(element.getNavigationElement()); } return null; }
getIdentifierNameRange
31,519
TextRange (PsiElement element) { if (element instanceof GrReferenceExpression referenceExpression) { PsiElement nameElement = referenceExpression.getReferenceNameElement(); TextRange stringContentRange = GrStringUtil.getStringContentRange(nameElement); if (stringContentRange != null) return stringContentRange.shiftRight(nameElement.getStartOffsetInParent()); } return null; }
getReferenceNameRange
31,520
ResolveSnapshot (PsiElement scope) { return new GroovyResolveSnapshot(scope); }
createSnapshot
31,521
boolean (@Nullable PsiElement element, @NotNull Editor editor, @NotNull PsiFile file) { if (!editor.getSettings().isVariableInplaceRenameEnabled()) return false; if (!(element instanceof GrVariable)) return false; if (element instanceof GrField) return false; final SearchScope scope = element.getUseScope(); if (!(scope instanceof LocalSearchScope)) return false; final PsiElement[] scopeElements = ((LocalSearchScope)scope).getScope(); return scopeElements.length == 1 || scopeElements.length == 2 && (scopeElements[0] instanceof GrDocComment ^ scopeElements[1] instanceof GrDocComment); }
isAvailable
31,522
VariableInplaceRenamer (@NotNull PsiElement elementToRename, @NotNull Editor editor) { return new GrVariableInplaceRenamer((PsiNameIdentifierOwner)elementToRename, editor); }
createRenamer
31,523
boolean (@Nullable PsiElement element, @NotNull Editor editor, @NotNull PsiFile file) { if (!editor.getSettings().isVariableInplaceRenameEnabled()) return false; return element instanceof GrMethod && file instanceof GroovyFile; }
isAvailable
31,524
MemberInplaceRenamer (@NotNull PsiElement element, @NotNull PsiNameIdentifierOwner elementToRename, @NotNull Editor editor) { return new GrMethodInplaceRenamer(elementToRename, element, editor); }
createMemberRenamer
31,525
void (@NotNull GrReferenceExpression refExpr) { if (!refExpr.isQualified()) { PsiElement resolved = refExpr.resolve(); if (resolved instanceof GrMember) { SmartPsiElementPointer key = pointerManager.createSmartPsiElementPointer(refExpr); SmartPsiElementPointer value = pointers.get(resolved); if (value == null) { value = pointerManager.createSmartPsiElementPointer(resolved); pointers.put(resolved, value); } myReferencesMap.put(key, value); } } super.visitReferenceExpression(refExpr); }
visitReferenceExpression
31,526
void (String hidingLocalName) { PsiDocumentManager.getInstance(myProject).commitDocument(myDocument); for (Map.Entry<SmartPsiElementPointer, SmartPsiElementPointer> entry : myReferencesMap.entrySet()) { qualify(entry.getKey().getElement(), entry.getValue().getElement(), hidingLocalName); } }
apply
31,527
void (PsiElement referent, PsiElement referee, String hidingLocalName) { if (referent instanceof GrReferenceExpression ref && referee instanceof GrMember) { if (!ref.isQualified() && hidingLocalName.equals(ref.getReferenceName())) { PsiUtil.qualifyMemberReference(ref, (GrMember)referee, hidingLocalName); } } }
qualify
31,528
boolean () { final Editor editor = myEditorTextField.getEditor(); if (editor != null) { new JavaReferenceImporter().autoImportReferenceAtCursor(editor, myCodeFragment); } return super.stopCellEditing(); }
stopCellEditing
31,529
JBPopup (List<? extends GrParameterListOwner> scopes, final Editor editor, final JBPopupOwner popupRef, final PairFunction<? super GrParameterListOwner, ? super PsiElement, Object> callback) { final JPanel panel = new JPanel(new BorderLayout()); final JCheckBox superMethod = new JCheckBox(GroovyBundle.message("change.base.method.label"), true); superMethod.setMnemonic(KeyEvent.VK_U); panel.add(superMethod, BorderLayout.SOUTH); final JBList list = new JBList(scopes.toArray()); list.setVisibleRowCount(5); list.setCellRenderer(new DefaultListCellRenderer() { @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); final String text; if (value instanceof PsiMethod method) { text = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE); final int flags = Iconable.ICON_FLAG_VISIBILITY; final Icon icon = method.getIcon(flags); if (icon != null) setIcon(icon); } else { LOG.assertTrue(value instanceof GrClosableBlock); setIcon(JetgroovyIcons.Groovy.Groovy_16x16); text = "{...}"; } setText(text); return this; } }); list.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION); list.setSelectedIndex(0); final List<RangeHighlighter> highlighters = new ArrayList<>(); list.addListSelectionListener(new ListSelectionListener() { @Override public void valueChanged(final ListSelectionEvent e) { final GrParameterListOwner selectedMethod = (GrParameterListOwner)list.getSelectedValue(); if (selectedMethod == null) return; dropHighlighters(highlighters); updateView(selectedMethod, editor, EditorColors.SEARCH_RESULT_ATTRIBUTES, highlighters, superMethod); } }); updateView(scopes.get(0), editor, EditorColors.SEARCH_RESULT_ATTRIBUTES, highlighters, superMethod); final JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(list); scrollPane.setBorder(null); panel.add(scrollPane, BorderLayout.CENTER); final List<Pair<ActionListener, KeyStroke>> keyboardActions = Collections.singletonList( Pair.create(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { final GrParameterListOwner ToSearchIn = (GrParameterListOwner)list.getSelectedValue(); final JBPopup popup = popupRef.get(); if (popup != null && popup.isVisible()) { popup.cancel(); } final PsiElement toSearchFor; if (ToSearchIn instanceof GrMethod method) { toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? method.findDeepestSuperMethod() : method; } else { toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? ToSearchIn.getParent() : null; } IdeFocusManager.findInstance().doWhenFocusSettlesDown(() -> callback.fun(ToSearchIn, toSearchFor), ModalityState.current()); } }, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0))); return JBPopupFactory.getInstance().createComponentPopupBuilder(panel, list) .setTitle(GroovyBundle.message("parameter.list.owner.chooser.title")) .setMovable(false) .setResizable(false) .setRequestFocus(true) .setKeyboardActions(keyboardActions).addListener(new JBPopupListener() { @Override public void onClosed(@NotNull LightweightWindowEvent event) { dropHighlighters(highlighters); } }).createPopup(); }
create
31,530
Component (JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); final String text; if (value instanceof PsiMethod method) { text = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, PsiFormatUtilBase.SHOW_CONTAINING_CLASS | PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_TYPE); final int flags = Iconable.ICON_FLAG_VISIBILITY; final Icon icon = method.getIcon(flags); if (icon != null) setIcon(icon); } else { LOG.assertTrue(value instanceof GrClosableBlock); setIcon(JetgroovyIcons.Groovy.Groovy_16x16); text = "{...}"; } setText(text); return this; }
getListCellRendererComponent
31,531
void (final ListSelectionEvent e) { final GrParameterListOwner selectedMethod = (GrParameterListOwner)list.getSelectedValue(); if (selectedMethod == null) return; dropHighlighters(highlighters); updateView(selectedMethod, editor, EditorColors.SEARCH_RESULT_ATTRIBUTES, highlighters, superMethod); }
valueChanged
31,532
void (ActionEvent e) { final GrParameterListOwner ToSearchIn = (GrParameterListOwner)list.getSelectedValue(); final JBPopup popup = popupRef.get(); if (popup != null && popup.isVisible()) { popup.cancel(); } final PsiElement toSearchFor; if (ToSearchIn instanceof GrMethod method) { toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? method.findDeepestSuperMethod() : method; } else { toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? ToSearchIn.getParent() : null; } IdeFocusManager.findInstance().doWhenFocusSettlesDown(() -> callback.fun(ToSearchIn, toSearchFor), ModalityState.current()); }
actionPerformed
31,533
void (@NotNull LightweightWindowEvent event) { dropHighlighters(highlighters); }
onClosed
31,534
void (GrParameterListOwner selectedMethod, Editor editor, TextAttributesKey attributesKey, List<? super RangeHighlighter> highlighters, JCheckBox superMethod) { final MarkupModel markupModel = editor.getMarkupModel(); final TextRange textRange = selectedMethod.getTextRange(); final RangeHighlighter rangeHighlighter = markupModel.addRangeHighlighter(attributesKey, textRange.getStartOffset(), textRange.getEndOffset(), HighlighterLayer.SELECTION - 1, HighlighterTargetArea.EXACT_RANGE); highlighters.add(rangeHighlighter); if (selectedMethod instanceof GrMethod) { superMethod.setText(GroovyBundle.message("change.base.method.label")); superMethod.setEnabled(((GrMethod)selectedMethod).findDeepestSuperMethod() != null); } else { superMethod.setText(GroovyBundle.message("change.usages.label")); superMethod.setEnabled(findVariableToUse(selectedMethod) != null); } }
updateView
31,535
GrVariable (@NotNull GrParameterListOwner owner) { final PsiElement parent = owner.getParent(); if (parent instanceof GrVariable) return (GrVariable)parent; if (parent instanceof GrAssignmentExpression && ((GrAssignmentExpression)parent).getRValue() == owner && !((GrAssignmentExpression)parent).isOperatorAssignment()) { final GrExpression lValue = ((GrAssignmentExpression)parent).getLValue(); if (lValue instanceof GrReferenceExpression) { final PsiElement resolved = ((GrReferenceExpression)lValue).resolve(); if (resolved instanceof GrVariable) { return (GrVariable)resolved; } } } return null; }
findVariableToUse
31,536
void (List<RangeHighlighter> highlighters) { for (RangeHighlighter highlighter : highlighters) { highlighter.dispose(); } highlighters.clear(); }
dropHighlighters
31,537
GrTypeComboBox (@Nullable PsiType type, @NotNull PsiElement context) { return new GrTypeComboBox(type, null, true, context, false); }
createTypeComboBoxWithDefType
31,538
GrTypeComboBox (@NotNull GrExpression expression) { return createTypeComboBoxFromExpression(expression, false); }
createTypeComboBoxFromExpression
31,539
GrTypeComboBox (@NotNull GrExpression expression, boolean selectDef) { PsiType type = expression.getType(); if (expression instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression)expression).resolve(); if (resolved instanceof PsiClass) { type = TypesUtil.createJavaLangClassType(type, expression); } } if (GroovyRefactoringUtil.isDiamondNewOperator(expression)) { LOG.assertTrue(expression instanceof GrNewExpression); PsiType expected = PsiImplUtil.inferExpectedTypeForDiamond(expression); return new GrTypeComboBox(type, expected, expected == null, expression, selectDef); } else { if (type == PsiTypes.nullType()) { type = PsiType.getJavaLangObject(expression.getManager(), expression.getResolveScope()); } return new GrTypeComboBox(type, null, true, expression, selectDef); } }
createTypeComboBoxFromExpression
31,540
GrTypeComboBox () { return new GrTypeComboBox(null, null, false, null, false); }
createEmptyTypeComboBox
31,541
void (@Nullable PsiType type, @NotNull PsiElement context) { final PsiElementFactory factory = JavaPsiFacade.getElementFactory(context.getProject()); final PsiType cl; if (type == null || type == PsiTypes.nullType()) { cl = factory.createTypeFromText(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, context); } else { cl = factory.createTypeFromText(GroovyCommonClassNames.GROOVY_LANG_CLOSURE + '<' + type.getCanonicalText() + '>', context); } addItem(new PsiTypeItem(cl, true)); }
addClosureTypesFrom
31,542
PsiType () { final Object selected = getSelectedItem(); assert selected instanceof PsiTypeItem; return ((PsiTypeItem)selected).getType(); }
getSelectedType
31,543
boolean () { return ((PsiTypeItem)getSelectedItem()).isClosure(); }
isClosureSelected
31,544
boolean (PsiType type) { if (!(type instanceof PsiClassType)) return false; PsiType[] parameters = ((PsiClassType)type).getParameters(); PsiClassType.ClassResolveResult classResolveResult = ((PsiClassType)type).resolveGenerics(); PsiClass clazz = classResolveResult.getElement(); if (clazz == null) return false; return clazz.getTypeParameters().length != parameters.length; }
isPartiallySubstituted
31,545
void (JComponent component, final GrTypeComboBox combo) { final AnAction arrow = new AnAction() { @Override public void actionPerformed(@NotNull AnActionEvent e) { if (e.getInputEvent() instanceof KeyEvent) { final int code = ((KeyEvent)e.getInputEvent()).getKeyCode(); scrollBy(code == KeyEvent.VK_DOWN ? 1 : code == KeyEvent.VK_UP ? -1 : 0, combo); } } }; final KeyboardShortcut up = new KeyboardShortcut(KeyStroke.getKeyStroke(KeyEvent.VK_UP, InputEvent.ALT_DOWN_MASK), null); final KeyboardShortcut down = new KeyboardShortcut(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.ALT_DOWN_MASK), null); arrow.registerCustomShortcutSet(new CustomShortcutSet(up, down), component); }
registerUpDownHint
31,546
void (@NotNull AnActionEvent e) { if (e.getInputEvent() instanceof KeyEvent) { final int code = ((KeyEvent)e.getInputEvent()).getKeyCode(); scrollBy(code == KeyEvent.VK_DOWN ? 1 : code == KeyEvent.VK_UP ? -1 : 0, combo); } }
actionPerformed
31,547
void (int delta, GrTypeComboBox combo) { if (delta == 0) return; final int size = combo.getModel().getSize(); int next = combo.getSelectedIndex() + delta; if (next < 0 || next >= size) { if (!UISettings.getInstance().getCycleScrolling()) { return; } next = (next + size) % size; } combo.setSelectedIndex(next); }
scrollBy
31,548
PsiType () { return myType; }
getType
31,549
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; PsiTypeItem that = (PsiTypeItem)o; if (myType == null) { if (that.myType != null) return false; } else { if (!myType.equals(that.myType)) return false; } return true; }
equals
31,550
int () { return myType == null ? 0 : myType.hashCode(); }
hashCode
31,551
String () { return myType == null ? "def" : myType.getPresentableText(); }
toString
31,552
boolean () { return isClosure; }
isClosure
31,553
String () { return myFileName; }
getFileName
31,554
void (@NotNull PsiReference reference, @NotNull List<? super UsageInfo> usages, @NotNull PsiNamedElement parameter, int paramIdx, boolean isVararg) { final PsiElement element = reference.getElement(); GrCall call = null; if (element instanceof GrCall) { call = (GrCall)element; } else if (element.getParent() instanceof GrCall) { call = (GrCall)element.getParent(); } if (call != null) { GrSignature signature = GrClosureSignatureUtil.createSignature(call); if (signature == null) return;//todo ??? GrClosureSignatureUtil.ArgInfo<PsiElement>[] argInfos = GrClosureSignatureUtil.mapParametersToArguments(signature, call); if (argInfos == null) return; //todo??? for (PsiElement arg : argInfos[paramIdx].args) { usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(arg, parameter, true)); } } else if (element instanceof GrDocMethodReference) { @NonNls final StringBuilder newText = new StringBuilder(); newText.append("/** @see "); GrDocReferenceElement holder = ((GrDocMethodReference)element).getReferenceHolder(); if (holder != null) { newText.append(holder.getText()); } newText.append('#'); newText.append(((GrDocMethodReference)element).getReferenceName()); newText.append('('); final List<GrDocMethodParameter> parameters = new ArrayList<>(Arrays.asList(((GrDocMethodReference)element).getParameterList().getParameters())); parameters.remove(paramIdx); newText.append(StringUtil.join(parameters, p -> p.getText(), ",")); newText.append(")*/"); usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(element, parameter, true) { @Override public void deleteElement() throws IncorrectOperationException { PsiElement e = getElement(); if (e != null) { ((GrDocMethodReference)e).bindToText(e.getProject(), newText.toString()); } } }); } }
createUsageInfoForParameter
31,555
void (@NotNull PsiReference reference, @NotNull List<? super UsageInfo> usages, @NotNull PsiElement typeParameter, int paramsCount, int index) { if (reference instanceof GrCodeReferenceElementImpl) { final @Nullable GrTypeArgumentList parameterList = ((GrCodeReferenceElementImpl)reference).getTypeArgumentList(); if (parameterList != null) { GrTypeElement[] typeArgs = parameterList.getTypeArgumentElements(); if (typeArgs.length > index) { usages.add(new SafeDeleteReferenceJavaDeleteUsageInfo(typeArgs.length == 1 ? parameterList : typeArgs[index], typeParameter, true) { @Override public void deleteElement() throws IncorrectOperationException { PsiElement element = getElement(); if (element != null) { PsiElement parent = element.getParent(); if (parent != null && parent.isValid()) { @Nullable PsiElement next = PsiTreeUtil.skipWhitespacesAndCommentsForward(element); if (next != null && PsiUtilCore.getElementType(next) == GroovyElementTypes.T_COMMA) { next.delete(); } else { @Nullable PsiElement prev = PsiTreeUtil.skipWhitespacesAndCommentsBackward(element); if (prev != null && PsiUtilCore.getElementType(prev) == GroovyElementTypes.T_COMMA) { prev.delete(); } } } } super.deleteElement(); } }); } } } }
createJavaTypeParameterUsageInfo
31,556
void (@NotNull PsiElement overriddenFunction, PsiElement @NotNull [] elements2Delete, @NotNull List<? super UsageInfo> result) { }
createCleanupOverriding
31,557
UsageInfo (PsiElement refElement, PsiReference reference) { return null; }
createExtendsListUsageInfo
31,558
PsiElement (PsiElement element, boolean onlyNonStatic) { PsiFile file = element.getContainingFile(); if (file instanceof GroovyFile) { GrImportStatement anImport = PsiTreeUtil.getParentOfType(element, GrImportStatement.class); if (!(anImport == null || anImport.isStatic() && onlyNonStatic)) { return anImport; } } return null; }
findImport
31,559
void (StringBuilder builder, GrEnumConstant constant) { GenerationUtil.writeDocComment(builder, constant, false); builder.append(constant.getName()); final GrArgumentList argumentList = constant.getArgumentList(); if (argumentList != null) { final GroovyResolveResult resolveResult = constant.advancedResolve(); GrSignature signature = GrClosureSignatureUtil.createSignature(resolveResult); new ArgumentListGenerator(builder, context.extend()).generate( signature, argumentList.getExpressionArguments(), argumentList.getNamedArguments(), GrClosableBlock.EMPTY_ARRAY, constant ); } final GrEnumConstantInitializer anonymousBlock = constant.getInitializingClass(); if (anonymousBlock != null) { builder.append("{\n"); new ClassGenerator(classNameProvider, this).writeMembers(builder, anonymousBlock); builder.append("\n}"); } }
writeEnumConstant
31,560
void (StringBuilder text, PsiMethod constructor, boolean isEnum) { writeMethod(text, constructor); }
writeConstructor
31,561
void (StringBuilder builder, PsiMethod method) { if (method == null) return; GenerationUtil.writeDocComment(builder, method, true); String name = method.getName(); boolean isAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT); PsiModifierList modifierList = method.getModifierList(); final PsiClass containingClass = method.getContainingClass(); if (method.isConstructor() && containingClass != null && containingClass.isEnum()) { ModifierListGenerator.writeModifiers(builder, modifierList, ModifierListGenerator.ENUM_CONSTRUCTOR_MODIFIERS); } else { ModifierListGenerator.writeModifiers(builder, modifierList); } if (method.hasTypeParameters()) { GenerationUtil.writeTypeParameters(builder, method, classNameProvider); builder.append(' '); } //append return type if (!method.isConstructor()) { PsiType retType = context.typeProvider.getReturnType(method); TypeWriter.writeType(builder, retType, method, classNameProvider); builder.append(' '); } builder.append(convertToJavaIdentifier(name)); if (method instanceof GroovyPsiElement) { context.searchForLocalVarsToWrap((GroovyPsiElement)method); } GenerationUtil.writeParameterList(builder, method.getParameterList().getParameters(), classNameProvider, context); if (method instanceof GrAnnotationMethod) { GrAnnotationMemberValue defaultValue = ((GrAnnotationMethod)method).getDefaultValue(); if (defaultValue != null) { builder.append("default "); defaultValue.accept(new AnnotationGenerator(builder, context)); } } GenerationUtil.writeThrowsList(builder, method.getThrowsList(), getMethodExceptions(method), classNameProvider); if (!isAbstract) { /* ************ body ********* */ if (method instanceof GrMethod) { if (method instanceof GrReflectedMethod && ((GrReflectedMethod)method).getSkippedParameters().length > 0) { builder.append("{\n").append(generateDelegateCall((GrReflectedMethod)method)).append("\n}\n"); } else { new CodeBlockGenerator(builder, context.extend()).generateMethodBody((GrMethod)method); } } else if (method instanceof GrAccessorMethod) { writeAccessorBody(builder, method); } else if (method instanceof LightMethodBuilder && containingClass instanceof GroovyScriptClass) { if ("main".equals(method.getName())) { writeMainScriptMethodBody(builder, method); } else if ("run".equals(method.getName())) { writeRunScriptMethodBody(builder, method); } } else { builder.append("{//todo\n}"); } } else { builder.append(';'); } }
writeMethod
31,562
StringBuilder (GrReflectedMethod method) { final GrParameter[] actualParams = method.getParameterList().getParameters(); final GrParameter[] parameters = method.getBaseMethod().getParameters(); Set<String> actual = new HashSet<>(actualParams.length); for (GrParameter param : actualParams) { actual.add(param.getName()); } StringBuilder builder = new StringBuilder(); if (method.isConstructor()) { builder.append("this"); } else { if (!PsiTypes.voidType().equals(context.typeProvider.getReturnType(method))) { builder.append("return "); } builder.append(method.getName()); } builder.append('('); for (GrParameter parameter : parameters) { if (actual.contains(parameter.getName())) { builder.append(parameter.getName()); } else { LOG.assertTrue(parameter.isOptional()); final GrExpression initializer = parameter.getInitializerGroovy(); LOG.assertTrue(initializer != null); builder.append(initializer.getText()); } builder.append(", "); } builder.delete(builder.length()-2, builder.length()); //builder.removeFromTheEnd(2); builder.append(')'); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(context.project); final GrStatement delegateCall; if (method.isConstructor()) { delegateCall = factory.createConstructorInvocation(builder.toString(), method); } else { delegateCall = factory.createStatementFromText(builder.toString(), method); } final StringBuilder result = new StringBuilder(); delegateCall.accept(new CodeBlockGenerator(result, this.context.extend())); return result; }
generateDelegateCall
31,563
void (StringBuilder builder, PsiMethod method) { final PsiClass containingClass = method.getContainingClass(); LOG.assertTrue(containingClass instanceof GroovyScriptClass); final PsiParameter[] parameters = method.getParameterList().getParameters(); LOG.assertTrue(parameters.length == 1); builder.append("{\nnew ").append(containingClass.getQualifiedName()).append("(new groovy.lang.Binding(").append(parameters[0].getName()) .append(")).run();\n}\n"); }
writeMainScriptMethodBody
31,564
void (StringBuilder builder, PsiMethod method) { builder.append("{\n"); final PsiClass containingClass = method.getContainingClass(); LOG.assertTrue(containingClass instanceof GroovyScriptClass); final PsiFile scriptFile = containingClass.getContainingFile(); LOG.assertTrue(scriptFile instanceof GroovyFile); LOG.assertTrue(((GroovyFile)scriptFile).isScript()); final List<GrStatement> exitPoints = ControlFlowUtils.collectReturns((GroovyFile)scriptFile); ExpressionContext extended = context.extend(); extended.searchForLocalVarsToWrap((GroovyPsiElement)scriptFile); new CodeBlockGenerator(builder, extended, exitPoints) .visitStatementOwner((GroovyFile)scriptFile, MissingReturnInspection .methodMissesSomeReturns((GroovyFile)scriptFile, MissingReturnInspection.ReturnStatus.mustReturnValue)); builder.append("\n}\n"); }
writeRunScriptMethodBody
31,565
void (StringBuilder builder, PsiMethod method) { final String propName = ((GrAccessorMethod)method).getProperty().getName(); if (((GrAccessorMethod)method).isSetter()) { final String paramName = method.getParameterList().getParameters()[0].getName(); builder.append("{\n"); if (method.hasModifierProperty(PsiModifier.STATIC)) { PsiClass containingClass = method.getContainingClass(); if (containingClass != null) { builder.append(containingClass.getName()); builder.append('.'); } } else { builder.append("this."); } builder.append(propName); builder.append(" = "); builder.append(paramName); builder.append(";\n}"); } else { builder.append("{\n return "); builder.append(propName); builder.append(";\n}"); } }
writeAccessorBody
31,566
PsiClassType[] (PsiMethod method) { return method.getThrowsList().getReferencedTypes(); //todo find method exceptions! }
getMethodExceptions
31,567
void (StringBuilder mainBuilder, GrVariableDeclaration variableDeclaration) { ExpressionContext extended = context.extend(); GrVariable[] variables = variableDeclaration.getVariables(); if (variables.length > 0 && variables[0] instanceof PsiField) { GenerationUtil.writeDocComment(mainBuilder, ((PsiField)variables[0]), true); } StringBuilder builder = new StringBuilder(); StringBuilder initBuilder = new StringBuilder(); initBuilder.append("{\n"); for (GrVariable variable : variables) { PsiType type = extended.typeProvider.getVarType(variable); ModifierListGenerator.writeModifiers(builder, variable.getModifierList()); TypeWriter.writeType(builder, type, variable); builder.append(' '); builder.append(variable.getName()); final GrExpression initializer = variable.getInitializerGroovy(); if (initializer != null) { int count = extended.myStatements.size(); StringBuilder initializerBuilder = new StringBuilder(); extended.searchForLocalVarsToWrap(initializer); initializer.accept(new ExpressionGenerator(initializerBuilder, extended)); if (extended.myStatements.size() == count) { //didn't use extra statements builder.append(" = ").append(initializerBuilder); } else { StringBuilder assignment = new StringBuilder().append(variable.getName()).append(" = ").append(initializerBuilder).append(';'); GenerationUtil.writeStatement(initBuilder, assignment, null, extended); } } builder.append(";\n"); } if (!extended.myStatements.isEmpty()) { initBuilder.append("}\n"); mainBuilder.append(initBuilder); } mainBuilder.append(builder); }
writeVariableDeclarations
31,568
Collection<PsiMethod> (PsiClass typeDefinition) { List<PsiMethod> result = ContainerUtil.filter( typeDefinition.getMethods(), m -> !GroovyObjectTransformationSupport.isGroovyObjectSupportMethod(m) ); if (typeDefinition instanceof GroovyScriptClass) { final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(context.project); final String name = typeDefinition.getName(); GrTypeDefinition tempClass = factory.createTypeDefinition("class " + name + " extends groovy.lang.Script {\n" + " def " + name + "(groovy.lang.Binding binding){\n" + " super(binding);\n" + " }\n" + " def " + name + "(){\n" + " super();\n" + " }\n" + "}"); result = ContainerUtil.append(result, tempClass.getCodeConstructors()); } return result; }
collectMethods
31,569
boolean () { return true; }
generateAnnotations
31,570
void (StringBuilder builder, PsiClass psiClass) { if (psiClass.getContainingClass() != null) return; if (psiClass instanceof PsiAnonymousClass) return; Map<PsiMethod, String> setters = context.getSetters(); Set<Map.Entry<PsiMethod, String>> entries = setters.entrySet(); if (ApplicationManager.getApplication().isUnitTestMode()) { entries = ImmutableSortedSet.copyOf(Map.Entry.comparingByValue(), entries); } for (Map.Entry<PsiMethod, String> entry : entries) { new SetterWriter(builder, psiClass, entry.getKey(), entry.getValue(), classNameProvider, context).write(); } final String name = context.getRefSetterName(); if (name != null) { builder.append("private static <T> T ").append(name). append("(groovy.lang.Reference<T> ref, T newValue) {\nref.set(newValue);\nreturn newValue;\n}"); } }
writePostponed
31,571
void (StringBuilder text, PsiClass typeDefinition) { final Collection<PsiClassType> implementsTypes = new LinkedHashSet<>(); Collections.addAll(implementsTypes, typeDefinition.getImplementsListTypes()); if (implementsTypes.isEmpty()) return; if (implementsTypes.size() == 1 && shouldSkipInImplements(typeDefinition, implementsTypes.iterator().next())) return; text.append(typeDefinition.isInterface() ? "extends " : "implements "); for (PsiClassType implementsType : implementsTypes) { if (shouldSkipInImplements(typeDefinition, implementsType)) { continue; } TypeWriter.writeType(text, implementsType, typeDefinition, classNameProvider); text.append(", "); } if (!implementsTypes.isEmpty()) text.delete(text.length() - 2, text.length()); text.append(' '); }
writeImplementsList
31,572
boolean (PsiClass typeDefinition, PsiClassType implementsType) { return implementsType.equalsToText(GROOVY_OBJECT) && typeDefinition instanceof GrTypeDefinition && !typeDefinition.isInterface() && !GenerationSettings.implementGroovyObjectAlways && !isInList(implementsType, ((GrTypeDefinition)typeDefinition).getImplementsClause()) && !containsMethodsOf((GrTypeDefinition)typeDefinition, GROOVY_OBJECT); }
shouldSkipInImplements
31,573
void (StringBuilder text, PsiClass typeDefinition) { final PsiClassType[] extendsClassesTypes = typeDefinition.getExtendsListTypes(); PsiClassType type = null; if (extendsClassesTypes.length > 0) { type = extendsClassesTypes[0]; } else { if (typeDefinition instanceof GrTypeDefinition) { if (GenerationSettings.implementGroovyObjectAlways || containsMethodsOf((GrTypeDefinition)typeDefinition, GROOVY_OBJECT)) { type = TypesUtil.createType(GROOVY_OBJECT_SUPPORT, typeDefinition); } } } if (type != null) { text.append("extends "); TypeWriter.writeType(text, type, typeDefinition, classNameProvider); text.append(' '); } }
writeExtendsList
31,574
boolean (@NotNull PsiClassType type, @Nullable GrReferenceList list) { if (list == null) return false; PsiClass resolved = type.resolve(); if (resolved == null) return true; PsiManager manager = list.getManager(); GrCodeReferenceElement[] elements = list.getReferenceElementsGroovy(); for (GrCodeReferenceElement element : elements) { if (manager.areElementsEquivalent(resolved, element.resolve())) { return true; } } return false; }
isInList
31,575
boolean (@NotNull GrTypeDefinition aClass, @NotNull final String fqn) { PsiClass classToSearch = JavaPsiFacade.getInstance(aClass.getProject()).findClass(fqn, aClass.getResolveScope()); if (classToSearch == null) return true; Set<String> methodsToFind = new HashSet<>(); for (PsiMethod method : classToSearch.getMethods()) { methodsToFind.add(method.getName()); } for (GrMethod method : aClass.getCodeMethods()) { if (!methodsToFind.contains(method.getName())) continue; for (HierarchicalMethodSignature superSignature : method.getHierarchicalMethodSignature().getSuperSignatures()) { PsiClass superClass = superSignature.getMethod().getContainingClass(); if (superClass != null && fqn.equals(superClass.getQualifiedName())) return true; } } return false; }
containsMethodsOf
31,576
void (GrListOrMap operand, GrTypeElement typeElement, final StringBuilder builder, ExpressionContext context) { final PsiType type = typeElement.getType(); final PsiClass psiClass; final PsiSubstitutor substitutor; if (type instanceof PsiClassType) { final PsiClassType.ClassResolveResult resolveResult = ((PsiClassType)type).resolveGenerics(); psiClass = resolveResult.getElement(); substitutor = resolveResult.getSubstitutor(); } else { psiClass = null; substitutor = PsiSubstitutor.EMPTY; } builder.append("new "); TypeWriter.writeTypeForNew(builder, type, operand); builder.append("() {\n"); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(operand.getProject()); final GrExpression caller = factory.createExpressionFromText("this"); for (GrNamedArgument arg : operand.getNamedArguments()) { final String name = arg.getLabelName(); final GrExpression expression = arg.getExpression(); if (name == null || !(expression instanceof GrClosableBlock closure)) continue; final GrParameter[] allParameters = closure.getAllParameters(); List<GrParameter> actual = new ArrayList<>(Arrays.asList(allParameters)); final PsiType clReturnType = context.typeProvider.getReturnType(closure); GrExpression[] args = new GrExpression[allParameters.length]; for (int i = 0; i < allParameters.length; i++) { args[i] = factory.createExpressionFromText(allParameters[i].getName()); } boolean singleParam = allParameters.length == 1; for (int param = allParameters.length; param >= 0; param--) { if (param < allParameters.length && !(actual.get(param).isOptional() || singleParam)) continue; if (param < allParameters.length) { final GrParameter opt = actual.remove(param); GrExpression initializer = opt.getInitializerGroovy(); if (initializer == null) { args[param] = factory.createExpressionFromText("null"); } else { args[param] = initializer; } } final GrParameter[] parameters = actual.toArray(GrParameter.EMPTY_ARRAY); final GrSignature signature = GrClosureSignatureUtil.createSignature(parameters, clReturnType); final GrMethod pattern = factory.createMethodFromSignature(name, signature); PsiMethod found = null; if (psiClass != null) { found = psiClass.findMethodBySignature(pattern, true); } if (found != null) { ModifierListGenerator.writeModifiers(builder, found.getModifierList(), ModifierListGenerator.JAVA_MODIFIERS_WITHOUT_ABSTRACT); } else { builder.append("public "); } PsiType returnType; if (found != null) { returnType = substitutor.substitute(context.typeProvider.getReturnType(found)); } else { returnType = signature.getReturnType(); } TypeWriter.writeType(builder, returnType, operand); builder.append(' ').append(name); GenerationUtil.writeParameterList(builder, parameters, new GeneratorClassNameProvider(), context); final ExpressionContext extended = context.extend(); extended.setInAnonymousContext(true); if (param == allParameters.length) { new CodeBlockGenerator(builder, extended).generateCodeBlock(allParameters, closure, false); } else { builder.append("{\n"); final ExpressionGenerator expressionGenerator = new ExpressionGenerator(builder, extended); GenerationUtil.invokeMethodByName(caller, name, args, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, expressionGenerator, arg); builder.append(";\n}\n"); } } } builder.append("}"); }
writeAnonymousMap
31,577
void () { final boolean isStatic = mySetter.hasModifierProperty(PsiModifier.STATIC); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myContext.project); PsiParameter[] parameters = mySetter.getParameterList().getParameters(); PsiParameter parameter = parameters[parameters.length - 1]; final PsiType parameterType = myContext.typeProvider.getParameterType(parameter); myBuffer.append("private static "); processTypeParameters(parameterType); myBuffer.append(myName); if (!(parameterType instanceof PsiPrimitiveType)) { parameter = factory.createParameter(parameter.getName(), "Value", null); } PsiParameter[] actual = inferActualParameters(isStatic, parameters, parameter); final GroovyPsiElement place = createStubMethod(actual); GenerationUtil.writeParameterList(myBuffer, actual, myClassNameProvider, myContext); writeBody(isStatic, parameters, parameter, place); }
write
31,578
void (boolean aStatic, PsiParameter @NotNull [] parameters, @NotNull PsiParameter parameter, final GroovyPsiElement place) { //method body myBuffer.append("{\n"); //arg initialization myContext.myUsedVarNames.add("propOwner"); final GrExpression[] args = generateArguments(parameters, place); new ExpressionGenerator(myBuffer, myContext).invokeMethodOn( mySetter, aStatic ? null : GroovyPsiElementFactory.getInstance(myContext.project).createExpressionFromText("propOwner", place), args, GrNamedArgument.EMPTY_ARRAY, GrClosableBlock.EMPTY_ARRAY, PsiSubstitutor.EMPTY, place ); myBuffer.append(";\n"); myBuffer.append("return ").append(parameter.getName()).append(";\n"); myBuffer.append("}\n"); }
writeBody
31,579
GroovyPsiElement (PsiParameter @NotNull [] parameters) { StringBuilder methodText = new StringBuilder("def ").append(myName).append('('); for (PsiParameter parameter : parameters) { methodText.append(parameter.getType().getCanonicalText()).append(' ').append(parameter.getName()).append(','); } if (parameters.length > 0) methodText.deleteCharAt(methodText.length() - 1); methodText.append("){}"); return GroovyPsiElementFactory.getInstance(myContext.project).createMethodFromText(methodText.toString(), mySetter); }
createStubMethod
31,580
void (PsiType parameterType) { //type parameters if (mySetter.hasTypeParameters()) { GenerationUtil.writeTypeParameters(myBuffer, mySetter, myClassNameProvider); } if (parameterType instanceof PsiPrimitiveType) { myBuffer.append(parameterType.getCanonicalText()).append(' '); } else { if (mySetter.hasTypeParameters()) { myBuffer.delete(myBuffer.length() - 1, myBuffer.length()); //builder.removeFromTheEnd(1); myBuffer.append(", "); } else { myBuffer.append('<'); } myBuffer.append("Value"); if (!parameterType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { myBuffer.append(" extends "); TypeWriter.writeType(myBuffer, parameterType, myClass, myClassNameProvider); } myBuffer.append('>'); myBuffer.append("Value "); } }
processTypeParameters
31,581
Object () { return copy(); }
clone
31,582
void () { myProps.put(myShouldInsertCurlyBrackets, true); }
setInsertCurlyBrackets
31,583
boolean (String name) { final Boolean aBoolean = myProps.get(name); return aBoolean != null && aBoolean.booleanValue(); }
getProp
31,584
boolean () { return getProp(myShouldInsertCurlyBrackets); }
shouldInsertCurlyBrackets
31,585
boolean () { return getProp(myInAnonymousContext); }
isInAnonymousContext
31,586
void (boolean inAnonymousContext) { myProps.put(myInAnonymousContext, inAnonymousContext); }
setInAnonymousContext
31,587
void (GroovyPsiElement root) { analyzedVars = LocalVarAnalyzer.searchForVarsToWrap(root, analyzedVars, this); }
searchForLocalVarsToWrap
31,588
String () { return myRefSetterName.get(); }
getRefSetterName
31,589
String (GroovyPsiElement context) { if (myRefSetterName.isNull()) { myRefSetterName.set(GenerationUtil.suggestMethodName(context, "setGroovyRef", this)); } return myRefSetterName.get(); }
getRefSetterName
31,590
String (PsiMethod setter, GroovyPsiElement place) { String name = setters.get(setter); if (name != null) return name; name = GenerationUtil.suggestMethodName(place, setter.getName(), this); setters.put(setter, name); return name; }
getSetterName
31,591
boolean (PsiClass aClass) { if (aClass == null) return false; return myClasses.contains(aClass); }
isClassConverted
31,592
String (@Nullable PsiClass psiClass, @Nullable PsiElement context) { if (context != null && psiClass != null) { psiClass = GenerationUtil.findAccessibleSuperClass(context, psiClass); } if (psiClass == null) { return CommonClassNames.JAVA_LANG_OBJECT; } if (psiClass instanceof GrTypeDefinition) { if (!myAllToCompile.contains(psiClass.getContainingFile().getVirtualFile())) { final PsiClass container = psiClass.getContainingClass(); if (container != null) { return getQualifiedClassName(container, null) + "$" + psiClass.getName(); } } } final String name = psiClass.getQualifiedName(); if (name!=null) return name; return psiClass.getName(); }
getQualifiedClassName
31,593
boolean () { return true; }
forStubs
31,594
void (StringBuilder builder, PsiType[] parameters, PsiElement context, ClassNameProvider classNameProvider) { if (parameters.length == 0) return; builder.append('<'); for (PsiType parameter : parameters) { if (parameter instanceof PsiPrimitiveType) { parameter = TypesUtil.boxPrimitiveType(parameter, context.getManager(), context.getResolveScope(), true); } TypeWriter.writeType(builder, parameter, context, classNameProvider); builder.append(", "); } builder.delete(builder.length()-2, builder.length()).append('>'); //builder.removeFromTheEnd(2).append('>'); }
writeTypeParameters
31,595
String (GrExpression expr, ExpressionContext expressionContext) { final DefaultGroovyVariableNameValidator nameValidator = new DefaultGroovyVariableNameValidator(expr, expressionContext.myUsedVarNames, true); final String[] varNames = GroovyNameSuggestionUtil.suggestVariableNames(expr, nameValidator); LOG.assertTrue(varNames.length > 0); expressionContext.myUsedVarNames.add(varNames[0]); return varNames[0]; }
suggestVarName
31,596
String (PsiType type, GroovyPsiElement context, ExpressionContext expressionContext) { final DefaultGroovyVariableNameValidator nameValidator = new DefaultGroovyVariableNameValidator(context, expressionContext.myUsedVarNames, true, true); if (type instanceof PsiPrimitiveType) type = TypesUtil.boxPrimitiveType(type, context.getManager(), context.getResolveScope()); final String[] varNames = GroovyNameSuggestionUtil.suggestVariableNameByType(type, nameValidator); LOG.assertTrue(varNames.length > 0); expressionContext.myUsedVarNames.add(varNames[0]); return varNames[0]; }
suggestVarName
31,597
String (String name, GroovyPsiElement context, ExpressionContext expressionContext) { return new DefaultGroovyVariableNameValidator(context, expressionContext.myUsedVarNames, true).validateName(name, true); }
validateName
31,598
void (StringBuilder builder, GrCodeReferenceElement referenceElement) { final GroovyResolveResult resolveResult = referenceElement.advancedResolve(); final PsiElement resolved = resolveResult.getElement(); if (resolved == null) { builder.append(referenceElement.getText()); return; } LOG.assertTrue(resolved instanceof PsiClass || resolved instanceof PsiPackage); if (resolved instanceof PsiClass) { builder.append(((PsiClass)resolved).getQualifiedName()); } else { builder.append(((PsiPackage)resolved).getQualifiedName()); } writeTypeParameters(builder, referenceElement.getTypeArguments(), referenceElement, new GeneratorClassNameProvider()); }
writeCodeReferenceElement
31,599
void (@Nullable GrExpression caller, @NotNull String methodName, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closureArgs, @NotNull ExpressionGenerator expressionGenerator, @NotNull GroovyPsiElement psiContext) { GroovyResolveResult call = resolveMethod(caller, methodName, exprs, namedArgs, closureArgs, psiContext); invokeMethodByResolveResult(caller, call, methodName, exprs, namedArgs, closureArgs, expressionGenerator, psiContext); }
invokeMethodByName