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,900
boolean (PsiElement position) { PsiElement parent = position.getParent(); PsiElement pparent = parent.getParent(); return parent instanceof GrVariable && ((GrVariable)parent).getNameIdentifierGroovy() == position && ((GrVariable)parent).getTypeElementGroovy() == null && pparent instanceof GrVariableDeclaration && ((GrVariableDeclaration)pparent).isTuple(); }
isTupleVarNameWithoutTypeDeclared
29,901
void (GrReferenceElement referenceElement, PrefixMatcher matcher, CompletionParameters parameters, Consumer<LookupElement> consumer) { if (referenceElement instanceof GrCodeReferenceElementImpl) { CompleteCodeReferenceElement.complete((GrCodeReferenceElement)referenceElement, matcher, consumer); } else if (referenceElement instanceof GrReferenceExpressionImpl) { CompleteReferenceExpression.processVariants(matcher, consumer, (GrReferenceExpressionImpl)referenceElement, parameters); } }
processVariants
29,902
boolean (PsiElement position) { //Closure cl={String x, <caret>... if (position == null) return false; if (position instanceof PsiWhiteSpace || position.getNode().getElementType() == GroovyTokenTypes.mNLS) { position = FilterPositionUtil.searchNonSpaceNonCommentBack(position); } boolean hasCommas = false; while (position != null) { PsiElement parent = position.getParent(); if (parent instanceof GrVariable) { PsiElement prev = FilterPositionUtil.searchNonSpaceNonCommentBack(parent); hasCommas = prev != null && prev.getNode().getElementType() == GroovyTokenTypes.mCOMMA; } if (parent instanceof GrClosableBlock) { PsiElement sibling = position.getPrevSibling(); while (sibling != null) { if (sibling instanceof GrParameterList) { return hasCommas; } boolean isComma = sibling instanceof LeafPsiElement && GroovyTokenTypes.mCOMMA == ((LeafPsiElement)sibling).getElementType(); hasCommas |= isComma; if (isComma || sibling instanceof PsiWhiteSpace || sibling instanceof PsiErrorElement || sibling instanceof GrVariableDeclaration || sibling instanceof GrReferenceExpression && !((GrReferenceExpression)sibling).isQualified() ) { sibling = sibling.getPrevSibling(); } else { return false; } } return false; } position = parent; } return false; } @Nullable public static PsiType getQualifierType(@Nullable PsiElement qualifier) { PsiType qualifierType = qualifier instanceof GrExpression ? ((GrExpression)qualifier).getType() : null; if (ResolveUtil.resolvesToClass(qualifier)) { PsiType type = ResolveUtil.unwrapClassType(qualifierType); if (type != null) { qualifierType = type; } } return qualifierType; } static boolean canResolveToPackage(@NotNull PsiElement qualifier) { return qualifier instanceof GrReferenceExpression && resolvePackageFqn((GrReferenceElement<?>)qualifier) != null; } }
isInPossibleClosureParameter
29,903
PsiType (@Nullable PsiElement qualifier) { PsiType qualifierType = qualifier instanceof GrExpression ? ((GrExpression)qualifier).getType() : null; if (ResolveUtil.resolvesToClass(qualifier)) { PsiType type = ResolveUtil.unwrapClassType(qualifierType); if (type != null) { qualifierType = type; } } return qualifierType; }
getQualifierType
29,904
boolean (@NotNull PsiElement qualifier) { return qualifier instanceof GrReferenceExpression && resolvePackageFqn((GrReferenceElement<?>)qualifier) != null; }
canResolveToPackage
29,905
Preference (@NotNull final PsiElement position) { if (INSIDE_REFERENCE_LIST.accepts(position)) { GrReferenceList list = (GrReferenceList)position.getParent().getParent(); PsiElement parent = list.getParent(); if (parent instanceof GrTypeDefinition cls) { if (cls.isInterface() && list == cls.getExtendsClause() || list == cls.getImplementsClause()) { return Preference.Interfaces; } if (list == cls.getExtendsClause()) { return Preference.Classes; } } if (parent instanceof GrMethod && ((GrMethod)parent).getThrowsList() == list) { return Preference.Exceptions; } } return null; }
getPreferredCondition
29,906
Comparable (@NotNull LookupElement element, @NotNull CompletionLocation location) { final PsiElement position = location.getCompletionParameters().getPosition(); if (position.getLanguage() == GroovyLanguage.INSTANCE) return null; if (!(position.getParent() instanceof GrReferenceExpression)) return null; Object o = element.getObject(); if (!(o instanceof GroovyResolveResult)) return 0; final PsiElement resolveContext = ((GroovyResolveResult)o).getCurrentFileResolveContext(); if (resolveContext == null) return 0; if (GdkMethodUtil.isInWithContext(resolveContext)) { return 1; } return 0; }
weigh
29,907
Integer (@NotNull LookupElement element, @NotNull CompletionLocation location) { if (!(location.getCompletionParameters().getPosition().getContainingFile() instanceof GroovyFileBase)) { return null; } Object o = element.getObject(); if (o instanceof ResolveResult) { o = ((ResolveResult)o).getElement(); } if (o instanceof PsiMethod && (GroovyPropertyUtils.isSimplePropertyAccessor((PsiMethod)o) || "setProperty".equals(((PsiMethod)o).getName()))) { return 1; } return 0; }
weigh
29,908
Comparable (@NotNull LookupElement element, @NotNull CompletionLocation location) { final PsiElement position = location.getCompletionParameters().getPosition(); if (!(position.getContainingFile() instanceof GroovyFileBase)) return null; Object o = element.getObject(); if (o instanceof ResolveResult) { o = ((ResolveResult)o).getElement(); } final PsiElement parent = position.getParent(); final PsiElement qualifier = parent instanceof GrReferenceElement ? ((GrReferenceElement<?>)parent).getQualifier() : null; if (qualifier == null) { if (o instanceof NamedArgumentDescriptor descriptor) { return switch (descriptor.getPriority()) { case ALWAYS_ON_TOP -> NotQualifiedKind.onTop; case AS_LOCAL_VARIABLE -> NotQualifiedKind.local; default -> NotQualifiedKind.unknown; }; } if (o instanceof PsiVariable && !(o instanceof PsiField)) { return NotQualifiedKind.local; } PsiTypeLookupItem item = element.as(PsiTypeLookupItem.CLASS_CONDITION_KEY); if (item != null && item.getBracketsCount() > 0) { return NotQualifiedKind.arrayType; } if (isPriorityKeyword(o)) return NotQualifiedKind.local; if (isLightElement(o)) return NotQualifiedKind.unknown; if (o instanceof PsiClass cls) { if (cls.isAnnotationType() && GrMainCompletionProvider.AFTER_AT.accepts(position)) { final GrAnnotation annotation = PsiTreeUtil.getParentOfType(position, GrAnnotation.class); if (annotation != null) { PsiElement annoParent = annotation.getParent(); PsiElement ownerToUse = annoParent instanceof PsiModifierList ? annoParent.getParent() : annoParent; PsiAnnotation.TargetType[] elementTypeFields = GrAnnotationImpl.getApplicableElementTypeFields(ownerToUse); if (AnnotationTargetUtil.findAnnotationTarget(cls, elementTypeFields) != null) { return NotQualifiedKind.restrictedClass; } } } if (GrMainCompletionProvider.IN_CATCH_TYPE.accepts(position) && InheritanceUtil.isInheritor(cls, CommonClassNames.JAVA_LANG_THROWABLE)) { return NotQualifiedKind.restrictedClass; } } if (o instanceof PsiMember member) { final PsiClass containingClass = member.getContainingClass(); if (isAccessor(member)) return NotQualifiedKind.accessor; if (o instanceof PsiClass cls && cls.getContainingClass() == null || o instanceof PsiPackage) return NotQualifiedKind.unknown; if (o instanceof PsiClass) return NotQualifiedKind.innerClass; if (PsiTreeUtil.isContextAncestor(containingClass, position, false)) return NotQualifiedKind.currentClassMember; return NotQualifiedKind.member; } return NotQualifiedKind.unknown; } else { if (o instanceof PsiEnumConstant) return QualifiedKind.enumConstant; if (isLightElement(o)) return QualifiedKind.unknown; if (o instanceof PsiMember) { if (isTrashMethod((PsiMember)o)) return QualifiedKind.unknown; if (isAccessor((PsiMember)o)) return QualifiedKind.accessor; if (isQualifierClassMember((PsiMember)o, qualifier)) { return QualifiedKind.currentClassMember; } if (o instanceof PsiClass && ((PsiClass)o).getContainingClass() == null || o instanceof PsiPackage) return QualifiedKind.unknown; if (o instanceof PsiClass) return QualifiedKind.innerClass; return QualifiedKind.member; } return QualifiedKind.unknown; } }
weigh
29,909
boolean (Object o) { return PRIORITY_KEYWORDS.contains(o); }
isPriorityKeyword
29,910
boolean (Object o) { return o instanceof LightElement && !(o instanceof GrPropertyForCompletion) && !(o instanceof GrAccessorMethod); }
isLightElement
29,911
boolean (PsiMember o) { final PsiClass containingClass = o.getContainingClass(); return containingClass != null && TRASH_CLASSES.contains(containingClass.getQualifiedName()); }
isTrashMethod
29,912
boolean (PsiMember member) { return member instanceof PsiMethod && (GroovyPropertyUtils.isSimplePropertyAccessor((PsiMethod)member) || "setProperty".equals(((PsiMethod)member).getName())); }
isAccessor
29,913
boolean (PsiMember member, PsiElement qualifier) { if (!(qualifier instanceof GrExpression)) return false; final PsiType type = ((GrExpression)qualifier).getType(); if (!(type instanceof PsiClassType)) return false; final PsiClass psiClass = ((PsiClassType)type).resolve(); if (psiClass == null) return false; return qualifier.getManager().areElementsEquivalent(member.getContainingClass(), psiClass); }
isQualifierClassMember
29,914
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { GrCatchClause catchClause = PsiTreeUtil.getParentOfType(psiElement, GrCatchClause.class); if (catchClause == null || catchClause.getBody() != null) return; if (!PsiTreeUtil.isAncestor(catchClause.getParameter(), psiElement, false)) return; final Document doc = editor.getDocument(); PsiElement lBrace = catchClause.getLBrace(); if (lBrace != null) return; PsiElement eltToInsertAfter = catchClause.getRParenth(); String text = "{\n}"; if (eltToInsertAfter == null) { eltToInsertAfter = catchClause.getParameter(); text = "){\n}"; } if (eltToInsertAfter != null) { doc.insertString(eltToInsertAfter.getTextRange().getEndOffset(), text); } }
apply
29,915
void (@NotNull PsiElement atCaret, @NotNull OrderedSet<PsiElement> res, boolean recurse) { res.add(0, atCaret); if (doNotStepInto(atCaret)) { if (!recurse) return; recurse = false; } PsiElement parent = atCaret.getParent(); if (atCaret instanceof GrClosableBlock && parent instanceof GrStringInjection && parent.getParent() instanceof GrString) { res.add(parent.getParent()); } if (parent instanceof GrArgumentList) { res.add(parent.getParent()); } //if (parent instanceof GrWhileStatement) { // res.add(parent); //} final PsiElement[] children = getChildren(atCaret); for (PsiElement child : children) { collectAllElements(child, res, recurse); } }
collectAllElements
29,916
boolean (PsiElement element) { return element instanceof PsiClass || element instanceof GrCodeBlock || element instanceof GrStatement && !(element instanceof GrExpression) || PsiUtil.isExpressionStatement(element) || element instanceof GrMethod; }
doNotStepInto
29,917
PsiElement (Editor editor, PsiFile psiFile) { PsiElement atCaret = super.getStatementAtCaret(editor, psiFile); if (atCaret instanceof PsiWhiteSpace) return null; while (atCaret != null && !PsiUtil.isExpressionStatement(atCaret)) { if (atCaret instanceof PsiMethod || atCaret instanceof GrDocComment || atCaret instanceof GrTypeDefinition) return atCaret; atCaret = atCaret.getParent(); } return atCaret; }
getStatementAtCaret
29,918
PsiElement[] (PsiElement element) { PsiElement psiChild = element.getFirstChild(); if (psiChild == null) return PsiElement.EMPTY_ARRAY; List<PsiElement> result = new ArrayList<>(); while (psiChild != null) { result.add(psiChild); psiChild = psiChild.getNextSibling(); } return PsiUtilCore.toPsiElementArray(result); }
getChildren
29,919
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (!(psiElement instanceof GrIfStatement ifStatement)) return; final Document document = editor.getDocument(); final GrStatement elseBranch = ifStatement.getElseBranch(); final PsiElement elseElement = ifStatement.getElseKeyword(); if (elseElement != null && (elseBranch == null || !(elseBranch instanceof GrBlockStatement) && GrForBodyFixer.startLine(editor.getDocument(), elseBranch) > GrForBodyFixer.startLine(editor.getDocument(), elseElement))) { document.insertString(elseElement.getTextRange().getEndOffset(), "{}"); } GrStatement thenBranch = ifStatement.getThenBranch(); if (thenBranch instanceof GrBlockStatement) return; boolean transformingOneLiner = false; if (thenBranch != null && GrForBodyFixer.startLine(editor.getDocument(), thenBranch) == GrForBodyFixer.startLine(editor.getDocument(), ifStatement)) { if (ifStatement.getCondition() != null) { return; } transformingOneLiner = true; } final PsiElement rParenth = ifStatement.getRParenth(); if (rParenth == null) return; if (elseBranch == null && !transformingOneLiner || thenBranch == null) { document.insertString(rParenth.getTextRange().getEndOffset(), "{}"); } else { document.insertString(rParenth.getTextRange().getEndOffset(), "{"); document.insertString(thenBranch.getTextRange().getEndOffset() + 1, "}"); } }
apply
29,920
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (psiElement instanceof GrListOrMap) { final PsiElement brack = ((GrListOrMap)psiElement).getRBrack(); if (brack == null) { editor.getDocument().insertString(psiElement.getTextRange().getEndOffset(), "]"); } } }
apply
29,921
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { final PsiElement parent = psiElement.getParent(); if (parent instanceof GrReferenceExpression && !(parent.getParent() instanceof GrMethodCall) && hasOnlyClosureParam((GrReferenceExpression)parent)) { final int endOffset = psiElement.getTextRange().getEndOffset(); editor.getDocument().insertString(endOffset, "{\n}"); } }
apply
29,922
boolean (GrReferenceExpression ref) { if (ref.resolve() != null) return false; GroovyResolveResult[] results = ref.multiResolve(true); for (GroovyResolveResult result : results) { final PsiElement element = result.getElement(); if (element instanceof PsiMethod) { final PsiParameter[] parameters = ((PsiMethod)element).getParameterList().getParameters(); if (parameters.length == 1 && parameters[0].getType().equalsToText(GroovyCommonClassNames.GROOVY_LANG_CLOSURE)) { return true; } } } return false; }
hasOnlyClosureParam
29,923
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (psiElement instanceof GrLiteral) { String text = psiElement.getText(); if (StringUtil.startsWith(text, "'''")) { if (!StringUtil.endsWith(text, "'''")) { editor.getDocument().insertString(psiElement.getTextRange().getEndOffset(), "'''"); } } else if (StringUtil.startsWith(text, "'")) { if (!StringUtil.endsWith(text, "'")) { editor.getDocument().insertString(psiElement.getTextRange().getEndOffset(), "'"); } } else if (StringUtil.startsWith(text, "\"\"\"")) { if (!StringUtil.endsWith(text, "\"\"\"")) { editor.getDocument().insertString(psiElement.getTextRange().getEndOffset(), "\"\"\""); } } else if (StringUtil.startsWith(text, "\"")) { if (!StringUtil.endsWith(text, "\"")) { editor.getDocument().insertString(psiElement.getTextRange().getEndOffset(), "\""); } } } }
apply
29,924
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (psiElement instanceof GrIfStatement ifStatement) { final Document doc = editor.getDocument(); final PsiElement rParen = ifStatement.getRParenth(); final PsiElement lParen = ifStatement.getLParenth(); final GrExpression condition = ifStatement.getCondition(); if (condition == null) { if (lParen == null || rParen == null) { int stopOffset = doc.getLineEndOffset(doc.getLineNumber(ifStatement.getTextRange().getStartOffset())); final GrStatement then = ifStatement.getThenBranch(); if (then != null) { stopOffset = Math.min(stopOffset, then.getTextRange().getStartOffset()); } stopOffset = Math.min(stopOffset, ifStatement.getTextRange().getEndOffset()); doc.replaceString(ifStatement.getTextRange().getStartOffset(), stopOffset, "if ()"); processor.registerUnresolvedError(ifStatement.getTextRange().getStartOffset() + "if (".length()); } else { processor.registerUnresolvedError(lParen.getTextRange().getEndOffset()); } } else if (rParen == null) { doc.insertString(condition.getTextRange().getEndOffset(), ")"); } } }
apply
29,925
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { GrForStatement forStatement = PsiTreeUtil.getParentOfType(psiElement, GrForStatement.class); if (forStatement == null) return; final Document doc = editor.getDocument(); PsiElement body = forStatement.getBody(); if (body instanceof GrBlockStatement) return; if (body != null && startLine(doc, body) == startLine(doc, forStatement)) return; PsiElement eltToInsertAfter = forStatement.getRParenth(); String text = "{}"; if (eltToInsertAfter == null) { eltToInsertAfter = forStatement; text = "){}"; } doc.insertString(eltToInsertAfter.getTextRange().getEndOffset(), text); }
apply
29,926
int (Document doc, PsiElement psiElement) { return doc.getLineNumber(psiElement.getTextRange().getStartOffset()); }
startLine
29,927
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (psiElement instanceof GrParameterList && psiElement.getParent() instanceof GrMethod) { PsiElement rParenth = ((GrParameterList)psiElement).getRParen(); // TODO ends with comma if (rParenth == null || !")".equals(rParenth.getText())) { GrParameterList list = (GrParameterList)psiElement; final GrParameter[] params = list.getParameters(); int offset; if (params.length == 0) { offset = list.getTextRange().getStartOffset() + 1; } else { offset = params[params.length - 1].getTextRange().getEndOffset(); } editor.getDocument().insertString(offset, ")"); } } }
apply
29,928
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (!(psiElement instanceof GrMethod method)) return; final PsiClass aClass = method.getContainingClass(); if (aClass != null && aClass.isInterface() || method.hasModifierProperty(PsiModifier.ABSTRACT)) return; final GrCodeBlock body = method.getBlock(); final Document doc = editor.getDocument(); if (body != null) { // See IDEADEV-1093. This is quite hacky heuristic but it seem to be best we can do. String bodyText = body.getText(); if (StringUtil.startsWithChar(bodyText, '{')) { final GrStatement[] statements = body.getStatements(); if (statements.length > 0) { // [todo] // if (statements[0] instanceof PsiDeclarationStatement) { // if (PsiTreeUtil.getDeepestLast(statements[0]) instanceof PsiErrorElement) { // if (method.getContainingClass().getRBrace() == null) { // doc.insertString(body.getTextRange().getStartOffset() + 1, "\n}"); // } // } // } } } return; } int endOffset = method.getTextRange().getEndOffset(); if (StringUtil.endsWithChar(method.getText(), ';')) { doc.deleteString(endOffset - 1, endOffset); endOffset--; } doc.insertString(endOffset, "{\n}"); }
apply
29,929
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (psiElement instanceof GrWhileStatement whileStatement) { final Document doc = editor.getDocument(); final PsiElement rParenth = whileStatement.getRParenth(); final PsiElement lParenth = whileStatement.getLParenth(); final GrCondition condition = whileStatement.getCondition(); if (condition == null) { if (lParenth == null || rParenth == null) { int stopOffset = doc.getLineEndOffset(doc.getLineNumber(whileStatement.getTextRange().getStartOffset())); final GrStatement block = whileStatement.getBody(); if (block != null) { stopOffset = Math.min(stopOffset, block.getTextRange().getStartOffset()); } stopOffset = Math.min(stopOffset, whileStatement.getTextRange().getEndOffset()); doc.replaceString(whileStatement.getTextRange().getStartOffset(), stopOffset, "while ()"); processor.registerUnresolvedError(whileStatement.getTextRange().getStartOffset() + "while (".length()); } else { processor.registerUnresolvedError(lParenth.getTextRange().getEndOffset()); } } else if (rParenth == null) { doc.insertString(condition.getTextRange().getEndOffset(), ")"); } } }
apply
29,930
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { GrSynchronizedStatement synchronizedStatement = PsiTreeUtil.getParentOfType(psiElement, GrSynchronizedStatement.class); if (synchronizedStatement == null || synchronizedStatement.getBody() != null) return; if (!PsiTreeUtil.isAncestor(synchronizedStatement.getMonitor(), psiElement, false)) return; final Document doc = editor.getDocument(); PsiElement eltToInsertAfter = synchronizedStatement.getRParenth(); String text = "{\n}"; if (eltToInsertAfter == null) { eltToInsertAfter = synchronizedStatement.getMonitor(); text = "){\n}"; } doc.insertString(eltToInsertAfter.getTextRange().getEndOffset(), text); }
apply
29,931
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { final GrArgumentList argList = psiElement instanceof GrCall ? ((GrCall)psiElement).getArgumentList() : null; if (argList == null || argList instanceof GrCommandArgumentList) return; GrCall call = (GrCall)psiElement; PsiElement parenth = argList.getLastChild(); if (parenth != null && ")".equals(parenth.getText()) || call.hasClosureArguments()) return; int endOffset = -1; for (PsiElement child = argList.getFirstChild(); child != null; child = child.getNextSibling()) { if (!(child instanceof PsiErrorElement errorElement)) continue; if (errorElement.getErrorDescription().contains("')'")) { endOffset = errorElement.getTextRange().getStartOffset(); break; } } if (endOffset == -1) { endOffset = argList.getTextRange().getEndOffset(); } final GrExpression[] params = argList.getExpressionArguments(); if (params.length > 0 && GrForBodyFixer.startLine(editor.getDocument(), argList) != GrForBodyFixer.startLine(editor.getDocument(), params[0])) { endOffset = argList.getTextRange().getStartOffset() + 1; } endOffset = CharArrayUtil.shiftBackward(editor.getDocument().getCharsSequence(), endOffset - 1, " \t\n") + 1; editor.getDocument().insertString(endOffset, ")"); }
apply
29,932
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { GrSwitchStatement switchStatement = PsiTreeUtil.getParentOfType(psiElement, GrSwitchStatement.class); if (switchStatement == null || switchStatement.getLBrace() != null) return; if (!PsiTreeUtil.isAncestor(switchStatement.getCondition(), psiElement, false)) return; final Document doc = editor.getDocument(); PsiElement lBrace = switchStatement.getLBrace(); if (lBrace != null) return; PsiElement eltToInsertAfter = switchStatement.getRParenth(); String text = "{\n}"; if (eltToInsertAfter == null) { eltToInsertAfter = switchStatement.getCondition(); text = "){\n}"; } doc.insertString(eltToInsertAfter.getTextRange().getEndOffset(), text); }
apply
29,933
void (@NotNull Editor editor, @NotNull GroovySmartEnterProcessor processor, @NotNull PsiElement psiElement) { if (!(psiElement instanceof GrWhileStatement whileStatement)) return; final Document doc = editor.getDocument(); PsiElement body = whileStatement.getBody(); if (body instanceof GrBlockStatement) return; if (body != null && GrForBodyFixer.startLine(editor.getDocument(), body) == GrForBodyFixer.startLine(editor.getDocument(), whileStatement) && whileStatement.getCondition() != null) return; final PsiElement rParenth = whileStatement.getRParenth(); assert rParenth != null; doc.insertString(rParenth.getTextRange().getEndOffset(), "{}"); }
apply
29,934
GrCodeBlock (int caret, PsiElement element) { GrStatement body = null; if (element instanceof GrMethod) return ((GrMethod)element).getBlock(); if (element instanceof GrMethodCall) { final GrClosableBlock[] arguments = ((GrMethodCall)element).getClosureArguments(); if (arguments.length > 0) return arguments[0]; else return null; } if (element instanceof GrIfStatement) { body = ((GrIfStatement)element).getThenBranch(); if (body != null && caret > body.getTextRange().getEndOffset()) { body = ((GrIfStatement)element).getElseBranch(); } } else if (element instanceof GrWhileStatement) { body = ((GrWhileStatement)element).getBody(); } else if (element instanceof GrForStatement) { body = ((GrForStatement)element).getBody(); } if (body instanceof GrBlockStatement) { return ((GrBlockStatement)body).getBlock(); } return null; }
getControlStatementBlock
29,935
boolean (PsiElement psiElement, PsiFile file, @NotNull Editor editor, boolean modified) { GrCodeBlock block = getControlStatementBlock(editor.getCaretModel().getOffset(), psiElement); if (block != null) { PsiElement firstElement = block.getFirstChild().getNextSibling(); final int offset = firstElement != null ? firstElement.getTextRange().getStartOffset() - 1 : block.getTextRange().getEndOffset(); editor.getCaretModel().moveToOffset(offset); } plainEnter(editor); return true; }
doEnter
29,936
void (@NotNull InsertionContext context, @NotNull LookupElement item) { int tailOffset = context.getTailOffset(); PsiElement argumentList = context.getFile().findElementAt(tailOffset - 1); while (argumentList != null && !(argumentList instanceof GrArgumentList) && !(argumentList instanceof GrListOrMap)) { argumentList = argumentList.getParent(); } final Editor editor = context.getEditor(); if (argumentList != null) { CodeStyleSettings settings = CodeStyle.getSettings(context.getFile()); GroovyCodeStyleSettings codeStyleSettings = settings.getCustomSettings(GroovyCodeStyleSettings.class); CommonCodeStyleSettings commonCodeStyleSettings = settings.getCommonSettings(GroovyLanguage.INSTANCE); boolean insertSpace = codeStyleSettings.SPACE_IN_NAMED_ARGUMENT; if (context.getCompletionChar() == ':' || (insertSpace && context.getCompletionChar() == ' ')) { context.setAddCompletionChar(false); } String argumentListText = argumentList.getText(); String s = argumentListText.substring(tailOffset - argumentList.getTextOffset()); s = StringUtil.trimEnd(s, ")"); if (s.trim().isEmpty()) { String toInsert = insertSpace ? ": " : ":"; editor.getDocument().insertString(tailOffset, toInsert); editor.getCaretModel().moveToOffset(tailOffset + toInsert.length()); } else { if (context.getCompletionChar() == Lookup.REPLACE_SELECT_CHAR) { char a = s.charAt(0); if (Character.isLetterOrDigit(a)) { return; } } Matcher m = Pattern.compile("([ \\t]*):([ \\t]*)(.*)", Pattern.DOTALL).matcher(s); if (m.matches()) { int caret = tailOffset + m.end(2); if (m.group(2).isEmpty()) { editor.getDocument().insertString(caret, " "); caret++; } editor.getCaretModel().moveToOffset(caret); } else { m = Pattern.compile("([ \\t]*)([\\n \\t]*)[\\],](.*)", Pattern.DOTALL).matcher(s); if (m.matches()) { String toInsert = insertSpace ? ": " : ":"; editor.getDocument().replaceString(tailOffset, tailOffset + m.start(2), toInsert); editor.getCaretModel().moveToOffset(tailOffset + toInsert.length()); } else { m = Pattern.compile("([ \\t]*)(.*)", Pattern.DOTALL).matcher(s); if (!m.matches()) throw new RuntimeException("This pattern must match any non-empty string! (" + s + ")"); StringBuilder sb = new StringBuilder(3); sb.append(':'); int shiftCaret = 1; if (insertSpace) { sb.append(' '); shiftCaret++; } if (!m.group(2).startsWith("\n") && commonCodeStyleSettings.SPACE_AFTER_COMMA) { sb.append(' '); } editor.getDocument().replaceString(tailOffset, tailOffset + m.start(2), sb); editor.getCaretModel().moveToOffset(tailOffset + shiftCaret); } } } editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); editor.getSelectionModel().removeSelection(); } }
handleInsert
29,937
void (@NotNull final InsertionContext context, @NotNull LookupElement item) { final PsiClassType.ClassResolveResult resolveResult = myClassType.resolveGenerics(); final PsiClass psiClass = resolveResult.getElement(); if (psiClass == null || !psiClass.isValid()) { return; } GroovyPsiElement place = PsiTreeUtil.findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), GroovyPsiElement.class, false); boolean hasParams = place != null && GroovyCompletionUtil.hasConstructorParameters(psiClass, place); if (myTriggerFeature) { FeatureUsageTracker.getInstance().triggerFeatureUsed(JavaCompletionFeatures.AFTER_NEW); } if (hasParams) { ParenthesesInsertHandler.WITH_PARAMETERS.handleInsert(context, item); } else { ParenthesesInsertHandler.NO_PARAMETERS.handleInsert(context, item); } shortenRefsInGenerics(context); if (hasParams) { AutoPopupController.getInstance(context.getProject()).autoPopupParameterInfo(context.getEditor(), null); } PsiDocumentManager.getInstance(context.getProject()).doPostponedOperationsAndUnblockDocument(context.getDocument()); if (psiClass.hasModifierProperty(PsiModifier.ABSTRACT)) { final Editor editor = context.getEditor(); final int offset = context.getTailOffset(); editor.getDocument().insertString(offset, " {}"); editor.getCaretModel().moveToOffset(offset + 2); context.setLaterRunnable(generateAnonymousBody(editor, context.getFile())); } }
handleInsert
29,938
void (InsertionContext context) { int offset = context.getStartOffset(); final String text = context.getDocument().getText(); while (text.charAt(offset) != '<' && text.charAt(offset) != '(') { offset++; } if (text.charAt(offset) == '<') { GroovyCompletionUtil.shortenReference(context.getFile(), offset); } }
shortenRefsInGenerics
29,939
Runnable (final Editor editor, final PsiFile file) { final Project project = file.getProject(); PsiDocumentManager.getInstance(project).commitAllDocuments(); int offset = editor.getCaretModel().getOffset(); PsiElement element = file.findElementAt(offset); if (element == null) return null; PsiElement parent = element.getParent().getParent(); if (!(parent instanceof PsiAnonymousClass)) return null; return ConstructorInsertHandler.genAnonymousBodyFor((PsiAnonymousClass)parent, editor, file, project); }
generateAnonymousBody
29,940
void (@NotNull InsertionContext context, @NotNull LookupElement item) { context.getDocument().deleteString(context.getStartOffset(), context.getTailOffset()); PsiMethod method = (PsiMethod)item.getObject(); List<PsiMethod> prototypes = OverrideImplementUtil.overrideOrImplementMethod(myPsiClass, method, false); context.commitDocument(); GenerateMembersUtil.insertMembersAtOffset(context.getFile(), context.getStartOffset(), OverrideImplementUtil.convert2GenerationInfos(prototypes)); }
handleInsert
29,941
void (@NotNull InsertionContext context, @NotNull LookupElement item) { if (!(item.getObject() instanceof PsiMethod method)) { return; } PsiDocumentManager.getInstance(context.getProject()).commitDocument(context.getEditor().getDocument()); final Editor editor = context.getEditor(); final PsiParameter[] parameters = method.getParameterList().getParameters(); final StringBuilder buffer = new StringBuilder(); final CharSequence chars = editor.getDocument().getCharsSequence(); int endOffset = editor.getCaretModel().getOffset(); final Project project = context.getProject(); int afterSharp = CharArrayUtil.shiftBackwardUntil(chars, endOffset - 1, "#") + 1; int signatureOffset = afterSharp; PsiElement element = context.getFile().findElementAt(signatureOffset - 1); final CommonCodeStyleSettings styleSettings = CodeStyle.getLanguageSettings(context.getFile(), GroovyLanguage.INSTANCE); PsiDocTag tag = PsiTreeUtil.getParentOfType(element, PsiDocTag.class); if (context.getCompletionChar() == Lookup.REPLACE_SELECT_CHAR) { final PsiDocTagValue value = tag.getValueElement(); endOffset = value.getTextRange().getEndOffset(); } editor.getDocument().deleteString(afterSharp, endOffset); editor.getCaretModel().moveToOffset(signatureOffset); editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE); editor.getSelectionModel().removeSelection(); buffer.append(method.getName()).append("("); final int afterParenth = afterSharp + buffer.length(); for (int i = 0; i < parameters.length; i++) { final PsiType type = TypeConversionUtil.erasure(parameters[i].getType()); buffer.append(type.getCanonicalText()); if (i < parameters.length - 1) { buffer.append(","); if (styleSettings.SPACE_AFTER_COMMA) buffer.append(" "); } } buffer.append(")"); if (!(tag instanceof PsiInlineDocTag)) { buffer.append(" "); } else { final int currentOffset = editor.getCaretModel().getOffset(); if (chars.charAt(currentOffset) == '}') { afterSharp++; } else { buffer.append("} "); }
handleInsert
29,942
void (final Project project, final Editor editor, InsertionContext context, int offset) { PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument()); final PsiElement element = context.getFile().findElementAt(offset); final GrDocMemberReference tagValue = PsiTreeUtil.getParentOfType(element, GrDocMemberReference.class); if (tagValue != null) { try { JavaCodeStyleManager.getInstance(project).shortenClassReferences(tagValue); } catch (IncorrectOperationException e) { LOG.error(e); } } PsiDocumentManager.getInstance(context.getProject()).commitAllDocuments(); }
shortenReferences
29,943
void (@NotNull LookupElement element) { myAccumulator.add(element); }
consume
29,944
void (CompletionParameters parameters) { Set<LookupElement> newSet = new HashSet<>(myAccumulator); myAccumulator.clear(); myResultSet.addAllElements(newSet); }
fastElementsProcessed
29,945
void () { close(); myResultSet.stopHere(); }
interrupt
29,946
void () { myResultSet.addAllElements(myAccumulator); }
close
29,947
GroovyCompletionConsumer (@NotNull Function<? super CompletionResultSet, ? extends CompletionResultSet> transformer) { return new AccumulatingGroovyCompletionConsumer(transformer.apply(getCompletionResultSet()), myAccumulator); }
transform
29,948
CompletionResultSet () { return myResultSet; }
getCompletionResultSet
29,949
void (@NotNull LookupElement element) { myResultSet.consume(element); }
consume
29,950
void () { myResultSet.stopHere(); }
interrupt
29,951
void () { }
close
29,952
GroovyCompletionConsumer (@NotNull Function<? super CompletionResultSet, ? extends CompletionResultSet> transformer) { return new FastGroovyCompletionConsumer(transformer.apply(getCompletionResultSet())); }
transform
29,953
CompletionResultSet () { return myResultSet; }
getCompletionResultSet
29,954
void (@NotNull final PsiReferenceRegistrar registrar) { registrar.registerReferenceProvider(PlatformPatterns.psiElement(GrLiteral.class), new PropertiesReferenceProvider(), PsiReferenceRegistrar.LOWER_PRIORITY); registrar.registerReferenceProvider(GroovyPatterns.stringLiteral().withParent(GrAnnotationNameValuePair.class), new SpockUnrollReferenceProvider()); }
registerReferenceProviders
29,955
boolean (InsertionContext context, int startOffset, LookupElement item) { PsiFile file = context.getFile(); if (!(file instanceof GroovyFile)) return false; PsiElement element = file.findElementAt(startOffset); while (element != null && !(element instanceof PsiFile) && !(element instanceof GrDocComment)) { element = element.getParent(); } if (!(element instanceof GrDocComment)) return false; int offset = context.getEditor().getCaretModel().getOffset(); String text = file.getText(); return offset < text.length() && item.getObject() instanceof PsiMethod; }
isAcceptable
29,956
void (InsertionContext context, int startOffset, LookupElement item) { Editor editor = context.getEditor(); Object o = item.getObject(); assert o instanceof PsiMethod; PsiMethod method = (PsiMethod) o; StringBuffer buffer = new StringBuffer(); buffer.append("("); PsiParameterList params = method.getParameterList(); int count = params.getParametersCount(); int i = 0; for (PsiParameter parameter : params.getParameters()) { PsiType type = parameter.getType(); String text = type.getCanonicalText(); if (type instanceof PsiEllipsisType) { text = text.substring(0, text.length() - 3) + "[]"; } buffer.append(PsiTypesUtil.unboxIfPossible(text)); if (i < count - 1) { buffer.append(", "); } i++; } buffer.append(") "); CaretModel caretModel = editor.getCaretModel(); int endOffset = shortenParamterReferences(context, startOffset, method, buffer); caretModel.moveToOffset(endOffset); }
handleInsert
29,957
int (InsertionContext context, int startOffset, PsiMethod method, StringBuffer buffer) { Document document = context.getEditor().getDocument(); int offset = startOffset + method.getName().length(); String paramText = buffer.toString(); document.insertString(offset, paramText); int endOffset = offset + paramText.length(); final Project project = context.getProject(); PsiDocumentManager.getInstance(project).commitDocument(document); PsiReference ref = context.getFile().findReferenceAt(startOffset); if (ref instanceof GrDocMethodReference methodReference) { GrDocMethodParams list = methodReference.getParameterList(); for (GrDocMethodParameter parameter : list.getParameters()) { JavaCodeStyleManager.getInstance(project).shortenClassReferences(parameter); } endOffset = methodReference.getTextRange().getEndOffset() + 1; } return endOffset; }
shortenParamterReferences
29,958
IElementType () { return GroovyTokenTypes.mCOMMA; }
getActualParameterDelimiterType
29,959
IElementType () { return GroovyTokenTypes.mGT; }
getActualParametersRBraceType
29,960
Class<GrTypeArgumentList> () { return GrTypeArgumentList.class; }
getArgumentListClass
29,961
GrTypeArgumentList (@NotNull CreateParameterInfoContext context) { final GrTypeArgumentList parameterList = ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset(), GrTypeArgumentList.class); if (parameterList != null) { if (!(parameterList.getParent() instanceof GrCodeReferenceElement ref)) return null; final PsiElement resolved = ref.resolve(); if (!(resolved instanceof PsiTypeParameterListOwner)) return null; final PsiTypeParameter[] typeParams = ((PsiTypeParameterListOwner)resolved).getTypeParameters(); if (typeParams.length == 0) return null; context.setItemsToShow(typeParams); return parameterList; } return null; }
findElementForParameterInfo
29,962
void (@NotNull GrTypeArgumentList element, @NotNull CreateParameterInfoContext context) { context.showHint(element, element.getTextRange().getStartOffset() + 1, this); }
showParameterInfo
29,963
GrTypeArgumentList (@NotNull UpdateParameterInfoContext context) { return ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset(), GrTypeArgumentList.class); }
findElementForUpdatingParameterInfo
29,964
void (@NotNull GrTypeArgumentList parameterOwner, @NotNull UpdateParameterInfoContext context) { int index = ParameterInfoUtils.getCurrentParameterIndex(parameterOwner.getNode(), context.getOffset(), getActualParameterDelimiterType()); context.setCurrentParameter(index); final Object[] objectsToView = context.getObjectsToView(); context.setHighlightedParameter(index < objectsToView.length && index >= 0 ? objectsToView[index] : null); }
updateParameterInfo
29,965
void (PsiTypeParameter p, @NotNull ParameterInfoUIContext context) { @NonNls StringBuilder buffer = new StringBuilder(); buffer.append(p.getName()); int highlightEndOffset = buffer.length(); buffer.append(" extends "); buffer.append(StringUtil.join(p.getSuperTypes(), t -> t.getPresentableText(), ", ")); context.setupUIComponentPresentation(buffer.toString(), 0, highlightEndOffset, false, false, false, context.getDefaultParameterColor()); }
updateUI
29,966
GroovyPsiElement (@NotNull CreateParameterInfoContext context) { GroovyPsiElement place = findAnchorElement(context.getEditor().getCaretModel().getOffset(), context.getFile()); if (place == null) { return null; } final List<Object> itemsToShow = collectParameterInfo(place); context.setItemsToShow(ArrayUtil.toObjectArray(itemsToShow)); return place; }
findElementForParameterInfo
29,967
GroovyPsiElement (@NotNull UpdateParameterInfoContext context) { return findAnchorElement(context.getEditor().getCaretModel().getOffset(), context.getFile()); }
findElementForUpdatingParameterInfo
29,968
GroovyPsiElement (int offset, PsiFile file) { PsiElement element = file.findElementAt(offset); if (element == null) return null; GroovyPsiElement argList = PsiTreeUtil.getParentOfType(element, GrArgumentList.class); if (argList != null) return argList; final GrCall call = PsiTreeUtil.getParentOfType(element, GrCall.class); if (call != null) { argList = call.getArgumentList(); if (argList != null && argList.getTextRange().contains(element.getTextRange().getStartOffset())) return argList; } else { offset = CharArrayUtil.shiftBackward(file.getText(), offset, "\n\t "); if (offset <= 0) return null; element = file.findElementAt(offset); if (element != null && element.getParent() instanceof GrReferenceExpression) return (GroovyPsiElement) element.getParent(); } return null; }
findAnchorElement
29,969
void (@NotNull GroovyPsiElement place, @NotNull CreateParameterInfoContext context) { context.showHint(place, place.getTextRange().getStartOffset(), this); }
showParameterInfo
29,970
List<Object> (@NotNull GroovyPsiElement place) { GroovyResolveResult[] variants = ResolveUtil.getCallVariants(place); final List<Object> elementToShow = new ArrayList<>(); final PsiElement parent = place.getParent(); if (parent instanceof GrMethodCall) { final GrExpression invoked = ((GrMethodCall)parent).getInvokedExpression(); if (isPropertyOrVariableInvoked(invoked)) { final PsiType type = invoked.getType(); if (type instanceof GrClosureType) { addSignatureVariant(elementToShow, (GrClosureType)type); } else if (type != null) { addMethodAndClosureVariants(elementToShow, ResolveUtil.getMethodCandidates(type, "call", invoked, PsiUtil.getArgumentTypes(place, true))); } } else { addMethodAndClosureVariants(elementToShow, variants); } } else { elementToShow.addAll(Arrays.asList(variants)); } filterOutReflectedMethods(elementToShow); return elementToShow; }
collectParameterInfo
29,971
void (@NotNull List<Object> elementToShow, GroovyResolveResult @NotNull [] variants) { for (GroovyResolveResult variant : variants) { final PsiElement element = variant.getElement(); if (element instanceof PsiMethod) { elementToShow.add(variant); } else if (element instanceof GrVariable) { final PsiType type = ((GrVariable)element).getTypeGroovy(); if (type instanceof GrClosureType) { addSignatureVariant(elementToShow, (GrClosureType)type); } } } }
addMethodAndClosureVariants
29,972
void (@NotNull final List<Object> elementToShow, @NotNull GrClosureType type) { elementToShow.addAll(type.getSignatures()); }
addSignatureVariant
29,973
void (List toShow) { Set<GrMethod> methods = new HashSet<>(); for (Iterator iterator = toShow.iterator(); iterator.hasNext(); ) { Object next = iterator.next(); if (next instanceof GroovyResolveResult) { final PsiElement element = ((GroovyResolveResult)next).getElement(); if (element instanceof GrReflectedMethod) { final GrMethod base = ((GrReflectedMethod)element).getBaseMethod(); if (!methods.add(base)) { iterator.remove(); } } } } }
filterOutReflectedMethods
29,974
boolean (GrExpression invoked) { if (!(invoked instanceof GrReferenceExpression)) return false; final GroovyResolveResult resolveResult = ((GrReferenceExpression)invoked).advancedResolve(); return resolveResult.isInvokedOnProperty() || resolveResult.getElement() instanceof PsiVariable; }
isPropertyOrVariableInvoked
29,975
void (@NotNull GroovyPsiElement place, @NotNull UpdateParameterInfoContext context) { int offset = context.getEditor().getCaretModel().getOffset(); offset = CharArrayUtil.shiftForward(context.getEditor().getDocument().getText(), offset, " \t\n"); final int currIndex = getCurrentParameterIndex(place, offset); context.setCurrentParameter(currIndex); final Object[] objects = context.getObjectsToView(); Outer: for (int i = 0; i < objects.length; i++) { PsiType[] parameterTypes = null; PsiType[] argTypes = null; PsiSubstitutor substitutor = null; if (objects[i] instanceof GroovyResolveResult resolveResult) { PsiNamedElement namedElement = (PsiNamedElement)resolveResult.getElement(); if (namedElement instanceof GrReflectedMethod) namedElement = ((GrReflectedMethod)namedElement).getBaseMethod(); substitutor = resolveResult.getSubstitutor(); assert namedElement != null; if (!namedElement.isValid()) { context.setUIComponentEnabled(i, false); continue Outer; } if (namedElement instanceof PsiMethod method) { PsiParameter[] parameters = method.getParameterList().getParameters(); parameters = updateConstructorParams(method, parameters, context.getParameterOwner()); parameterTypes = PsiType.createArray(parameters.length); for (int j = 0; j < parameters.length; j++) { parameterTypes[j] = parameters[j].getType(); } argTypes = PsiUtil.getArgumentTypes(place, false); } if (argTypes == null) continue; } else if (objects[i] instanceof GrSignature signature) { argTypes = PsiUtil.getArgumentTypes(place, false); parameterTypes = PsiType.createArray(signature.getParameterCount()); int j = 0; for (GrClosureParameter parameter : signature.getParameters()) { parameterTypes[j++] = parameter.getType(); } } else { continue Outer; } assert argTypes != null; if (argTypes.length > currIndex) { if (parameterTypes.length <= currIndex) { context.setUIComponentEnabled(i, false); continue; } else { for (int j = 0; j < currIndex; j++) { PsiType argType = argTypes[j]; final PsiType paramType = substitutor != null ? substitutor.substitute(parameterTypes[j]) : parameterTypes[j]; if (!TypesUtil.isAssignableByMethodCallConversion(paramType, argType, place)) { context.setUIComponentEnabled(i, false); break Outer; } } } } context.setUIComponentEnabled(i, true); } }
updateParameterInfo
29,976
int (GroovyPsiElement place, int offset) { if (place instanceof GrArgumentList list) { int idx = (list.getNamedArguments().length > 0) ? 1 : 0; for (PsiElement child = list.getFirstChild(); child != null; child = child.getNextSibling()) { if (child.getTextRange().contains(offset)) { if (child instanceof GrNamedArgument) return 0; return idx; } if (child.getNode().getElementType() == GroovyTokenTypes.mCOMMA) idx++; if (isNamedArgWithPriorComma(child)) idx--; } } return -1; }
getCurrentParameterIndex
29,977
boolean (PsiElement child) { if (!(child instanceof GrNamedArgument)) return false; final PsiElement element = PsiUtil.skipWhitespacesAndComments(child.getPrevSibling(), false); return element != null && element.getNode().getElementType() == GroovyTokenTypes.mCOMMA; }
isNamedArgWithPriorComma
29,978
void (Object o, @NotNull ParameterInfoUIContext context) { CodeInsightSettings settings = CodeInsightSettings.getInstance(); if (o == null) return; Object element; if (o instanceof GroovyResolveResult) { element = ((GroovyResolveResult)o).getElement(); if (element == null || !((PsiElement)element).isValid()) { context.setUIComponentEnabled(false); return; } } else if (o instanceof GrSignature) { if (!((GrSignature)o).isValid()) { context.setUIComponentEnabled(false); return; } element = o; } else { return; } int highlightStartOffset = -1; int highlightEndOffset = -1; final int currentParameter = context.getCurrentParameterIndex(); StringBuilder buffer = new StringBuilder(); if (element instanceof PsiMethod method) { if (method instanceof GrReflectedMethod) method = ((GrReflectedMethod)method).getBaseMethod(); if (settings.SHOW_FULL_SIGNATURES_IN_PARAMETER_INFO) { if (!method.isConstructor()) { PsiType returnType = PsiUtil.getSmartReturnType(method); if (returnType != null) { buffer.append(returnType.getPresentableText()); buffer.append(' '); } } buffer.append(method.getName()); buffer.append('('); } PsiParameter[] params = method.getParameterList().getParameters(); params = updateConstructorParams(method, params, context.getParameterOwner()); int numParams = params.length; if (numParams > 0) { LOG.assertTrue(o instanceof GroovyResolveResult, o.getClass()); final PsiSubstitutor substitutor = ((GroovyResolveResult)o).getSubstitutor(); for (int j = 0; j < numParams; j++) { PsiParameter param = params[j]; int startOffset = buffer.length(); appendParameterText(param, substitutor, buffer); int endOffset = buffer.length(); if (j < numParams - 1) { buffer.append(", "); } if (context.isUIComponentEnabled() && (j == currentParameter || (j == numParams - 1 && param.isVarArgs() && currentParameter >= numParams))) { highlightStartOffset = startOffset; highlightEndOffset = endOffset; } } } else { buffer.append("no parameters"); } if (settings.SHOW_FULL_SIGNATURES_IN_PARAMETER_INFO) { buffer.append(")"); } } else if (element instanceof PsiClass) { buffer.append("no parameters"); } else if (element instanceof GrSignature) { GrClosureParameter[] parameters = ((GrSignature)element).getParameters(); if (parameters.length > 0) { for (int i = 0; i < parameters.length; i++) { if (i > 0) buffer.append(", "); int startOffset = buffer.length(); final PsiType psiType = parameters[i].getType(); if (psiType == null) { buffer.append("def"); } else { buffer.append(psiType.getPresentableText()); } buffer.append(' ').append(parameters[i].getName() != null ? parameters[i].getName() : "<unknown>"); int endOffset = buffer.length(); if (context.isUIComponentEnabled() && (i == currentParameter || (i == parameters.length - 1 && ((GrSignature)element).isVarargs() && currentParameter >= parameters.length))) { highlightStartOffset = startOffset; highlightEndOffset = endOffset; } final GrExpression initializer = parameters[i].getDefaultInitializer(); if (initializer != null) { buffer.append(" = ").append(initializer.getText()); } } } else { buffer.append("no parameters"); } } final boolean isDeprecated = o instanceof PsiDocCommentOwner && ((PsiDocCommentOwner) o).isDeprecated(); context.setupUIComponentPresentation( buffer.toString(), highlightStartOffset, highlightEndOffset, !context.isUIComponentEnabled(), isDeprecated, false, context.getDefaultParameterColor() ); }
updateUI
29,979
PsiParameter[] (PsiMethod method, PsiParameter[] params, PsiElement place) { if (GrInnerClassConstructorUtil.isInnerClassConstructorUsedOutsideOfItParent(method, place)) { GrMethod grMethod = (GrMethod)method; params = GrInnerClassConstructorUtil .addEnclosingInstanceParam(grMethod, method.getContainingClass().getContainingClass(), grMethod.getParameters(), true); } return params; }
updateConstructorParams
29,980
void (PsiParameter param, PsiSubstitutor substitutor, StringBuilder buffer) { if (param instanceof GrParameter grParam) { GroovyPresentationUtil.appendParameterPresentation(grParam, substitutor, TypePresentation.PRESENTABLE, buffer, false); final GrExpression initializer = grParam.getInitializerGroovy(); if (initializer != null) { buffer.append(" = ").append(initializer.getText()); } else if (grParam.isOptional()) { String defaultValue = PsiTypesUtil.getDefaultValueOfType(param.getType()); buffer.append(" = ").append(defaultValue); } } else { PsiType t = param.getType(); PsiType paramType = substitutor.substitute(t); buffer.append(paramType.getPresentableText()); String name = param.getName(); buffer.append(" "); buffer.append(name); } }
appendParameterText
29,981
IElementType () { return GroovyTokenTypes.mCOMMA; }
getActualParameterDelimiterType
29,982
IElementType () { return GroovyTokenTypes.mRPAREN; }
getActualParametersRBraceType
29,983
Class<GroovyPsiElement> () { return GroovyPsiElement.class; }
getArgumentListClass
29,984
IElementType () { return GroovyTokenTypes.mCOMMA; }
getActualParameterDelimiterType
29,985
IElementType () { return GroovyTokenTypes.mRPAREN; }
getActualParametersRBraceType
29,986
Class<GrAnnotationArgumentList> () { return GrAnnotationArgumentList.class; }
getArgumentListClass
29,987
GrAnnotationArgumentList (@NotNull CreateParameterInfoContext context) { return findAnchor(context.getEditor(), context.getFile()); }
findElementForParameterInfo
29,988
GrAnnotationArgumentList (@NotNull final Editor editor, @NotNull final PsiFile file) { PsiElement element = file.findElementAt(editor.getCaretModel().getOffset()); if (element == null) return null; return PsiTreeUtil.getParentOfType(element, GrAnnotationArgumentList.class); }
findAnchor
29,989
void (@NotNull GrAnnotationArgumentList argumentList, @NotNull CreateParameterInfoContext context) { final GrAnnotation parent = (GrAnnotation)argumentList.getParent(); final PsiElement resolved = parent.getClassReference().resolve(); if (resolved instanceof PsiClass && ((PsiClass)resolved).isAnnotationType()) { final PsiAnnotationMethod[] methods = extractAnnotationMethodsFromClass((PsiClass)resolved); context.setItemsToShow(methods); context.showHint(argumentList, argumentList.getTextRange().getStartOffset(), this); final PsiAnnotationMethod currentMethod = findAnnotationMethod(context.getFile(), context.getEditor()); if (currentMethod != null) { context.setHighlightedElement(currentMethod); } } }
showParameterInfo
29,990
PsiAnnotationMethod (@NotNull PsiFile file, @NotNull Editor editor) { PsiNameValuePair pair = ParameterInfoUtils.findParentOfType(file, inferOffset(editor), PsiNameValuePair.class); if (pair == null) return null; final PsiReference reference = pair.getReference(); final PsiElement resolved = reference != null ? reference.resolve() : null; return PsiUtil.isAnnotationMethod(resolved) ? (PsiAnnotationMethod)resolved : null; }
findAnnotationMethod
29,991
GrAnnotationArgumentList (@NotNull UpdateParameterInfoContext context) { return findAnchor(context.getEditor(), context.getFile()); }
findElementForUpdatingParameterInfo
29,992
void (@NotNull GrAnnotationArgumentList parameterOwner, @NotNull UpdateParameterInfoContext context) { context.setHighlightedParameter(findAnnotationMethod(context.getFile(), context.getEditor())); }
updateParameterInfo
29,993
int (@NotNull final Editor editor) { CharSequence chars = editor.getDocument().getCharsSequence(); int offset1 = CharArrayUtil.shiftForward(chars, editor.getCaretModel().getOffset(), " \t"); final char character = chars.charAt(offset1); if (character == ',' || character == ')') { offset1 = CharArrayUtil.shiftBackward(chars, offset1 - 1, " \t"); } return offset1; }
inferOffset
29,994
void (@NotNull PsiAnnotationMethod p, @NotNull ParameterInfoUIContext context) { @NonNls StringBuilder buffer = new StringBuilder(); final PsiType returnType = p.getReturnType(); assert returnType != null; buffer.append(returnType.getPresentableText()); buffer.append(" "); int highlightStartOffset = buffer.length(); buffer.append(p.getName()); int highlightEndOffset = buffer.length(); buffer.append("()"); final PsiAnnotationMemberValue defaultValue = p.getDefaultValue(); if (defaultValue != null) { buffer.append(" default "); buffer.append(defaultValue.getText()); } context.setupUIComponentPresentation(buffer.toString(), highlightStartOffset, highlightEndOffset, false, p.isDeprecated(), false, context.getDefaultParameterColor()); }
updateUI
29,995
GroovyDocHighlightingManager () { return INSTANCE; }
getInstance
29,996
TextAttributes (@NotNull TextAttributesKey attributesKey) { return EditorColorsManager.getInstance().getGlobalScheme().getAttributes(attributesKey); }
resolveAttributes
29,997
TextAttributes (@NotNull PsiClass aClass) { if (aClass.isInterface()) return getInterfaceNameAttributes(); if (aClass.isEnum()) return getEnumNameAttributes(); if (aClass instanceof PsiAnonymousClass) return getAnonymousClassNameAttributes(); if (aClass.hasModifierProperty(PsiModifier.ABSTRACT)) return getAbstractClassNameAttributes(); return getClassNameAttributes(); }
getClassDeclarationAttributes
29,998
TextAttributes (@NotNull PsiMethod method) { return method.isConstructor() ? getConstructorDeclarationAttributes() : getMethodDeclarationAttributes(); }
getMethodDeclarationAttributes
29,999
TextAttributes (@NotNull PsiField field) { boolean isStatic = field.hasModifierProperty(PsiModifier.STATIC); return isStatic ? getStaticFieldAttributes() : getInstanceFieldAttributes(); }
getFieldDeclarationAttributes