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,800
void (@NotNull PsiElement position, @NotNull GroovyCompletionConsumer result) { final GrTypeParameterList candidate = findTypeParameterListCandidate(position); if (candidate != null) { for (GrTypeParameter p : candidate.getTypeParameters()) { result.consume(new JavaPsiClassReferenceElement(p)); } } }
addUnfinishedMethodTypeParameters
29,801
void (PsiElement context, GroovyCompletionConsumer result) { final PsiElement parent = context.getParent(); if (GroovyCompletionUtil.isWildcardCompletion(context)) return; if (parent instanceof GrVariable variable) { if (context.equals(variable.getNameIdentifierGroovy())) { final PsiType type = variable.getTypeGroovy(); if (type != null) { final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(context.getProject()); VariableKind kind = variable instanceof GrParameter ? VariableKind.PARAMETER : variable instanceof GrField ? VariableKind.FIELD : VariableKind.LOCAL_VARIABLE; SuggestedNameInfo suggestedNameInfo = codeStyleManager.suggestVariableName(kind, null, null, type); String[] names = suggestedNameInfo.names; if (names.length > 0) { String name = names[0]; String newName = InlineMethodConflictSolver.suggestNewName(name, null, parent); if (!name.equals(newName)) { result.consume(LookupElementBuilder.create(newName)); return; } } for (String name : names) { result.consume(LookupElementBuilder.create(name)); } } GrExpression initializer = variable.getInitializerGroovy(); if (initializer != null) { for (String name : GroovyNameSuggestionUtil.suggestVariableNames(initializer, new DefaultGroovyVariableNameValidator(variable), variable.hasModifierProperty(PsiModifier.STATIC))) { result.consume(LookupElementBuilder.create(name)); } } } } }
suggestVariableNames
29,802
boolean (PsiElement position) { return IN_CATCH_TYPE.accepts(position) || AFTER_AT.accepts(position) || GroovyCompletionUtil.isFirstElementAfterPossibleModifiersInVariableDeclaration(position, true) || GroovyCompletionUtil.isTupleVarNameWithoutTypeDeclared(position); }
couldContainReference
29,803
GrTypeParameterList (@NotNull PsiElement position) { final PsiElement parent = position.getParent(); if (parent instanceof GrVariable) { final PsiElement pparent = parent.getParent(); if (pparent instanceof GrVariableDeclaration) { PsiElement candidate = PsiUtil.skipWhitespacesAndComments(parent.getPrevSibling(), false); if (candidate instanceof GrTypeParameterList) { return (GrTypeParameterList)candidate; } } } return null; }
findTypeParameterListCandidate
29,804
boolean (PsiElement position) { PsiElement parent = position.getParent(); if (parent instanceof GrReferenceElement) { return ((GrReferenceElement<?>)parent).getQualifier() == null; } return couldContainReference(position); }
isClassNamePossible
29,805
void (CompletionParameters parameters, final GroovyCompletionConsumer result, final JavaCompletionSession session) { addAllClasses(parameters, result::consume, session, result.getCompletionResultSet().getPrefixMatcher()); }
addAllClasses
29,806
void (CompletionParameters parameters, final Consumer<? super LookupElement> consumer, final JavaCompletionSession inheritors, final PrefixMatcher matcher) { final PsiElement position = parameters.getPosition(); final boolean afterNew = JavaClassNameCompletionContributor.AFTER_NEW.accepts(position); AllClassesGetter.processJavaClasses(parameters, matcher, parameters.getInvocationCount() <= 1, psiClass -> { for (JavaPsiClassReferenceElement element : JavaClassNameCompletionContributor .createClassLookupItems(psiClass, afterNew, new GroovyClassNameInsertHandler(), psiClass1 -> !inheritors.alreadyProcessed(psiClass1))) { consumer.consume(element); } }); }
addAllClasses
29,807
Runnable (final CompletionParameters parameters, final GrReferenceElement<?> reference, final JavaCompletionSession inheritorsHolder, final PrefixMatcher matcher, final @Nullable CompletionResultSet resultSet, final Consumer<? super LookupElement> _consumer) { final HashSet<LookupElement> addedElements = new HashSet<>(); final Consumer<LookupElement> consumer = new Consumer<>() { final Set<LookupElement> added = addedElements; @Override public void consume(LookupElement element) { if (added.add(element)) { _consumer.consume(element); } } }; final Map<PsiModifierListOwner, LookupElement> staticMembers = new HashMap<>(); final PsiElement qualifier = reference.getQualifier(); final PsiType qualifierType = GroovyCompletionUtil.getQualifierType(qualifier); if (reference instanceof GrReferenceExpression && (qualifier instanceof GrExpression || qualifier == null)) { for (String string : CompleteReferencesWithSameQualifier.getVariantsWithSameQualifier((GrReferenceExpression)reference, matcher, (GrExpression)qualifier)) { consumer.consume(LookupElementBuilder.create(string).withItemTextUnderlined(true)); } if (parameters.getInvocationCount() < 2 && qualifier != null && qualifierType == null && !canResolveToPackage(qualifier)) { if (resultSet != null && parameters.getInvocationCount() == 1) { resultSet.addLookupAdvertisement(GroovyBundle.message("invoke.completion.second.time.to.show.skipped.methods")); } return EmptyRunnable.INSTANCE; } } final List<LookupElement> zeroPriority = new ArrayList<>(); PsiClass qualifierClass = com.intellij.psi.util.PsiUtil.resolveClassInClassTypeOnly(qualifierType); final boolean honorExcludes = qualifierClass == null || !JavaCompletionUtil.isInExcludedPackage(qualifierClass, false); Consumer<LookupElement> elementConsumer = lookupElement -> { Object object = lookupElement.getObject(); if (object instanceof GroovyResolveResult) { object = ((GroovyResolveResult)object).getElement(); } if (isLightElementDeclaredDuringCompletion(object)) { return; } if (!(lookupElement instanceof LookupElementBuilder) && inheritorsHolder.alreadyProcessed(lookupElement)) { return; } if (honorExcludes && object instanceof PsiMember && JavaCompletionUtil.isInExcludedPackage((PsiMember)object, true)) { return; } if (!(object instanceof PsiClass)) { int priority = assignPriority(lookupElement, qualifierType); lookupElement = PrioritizedLookupElement.withPriority(lookupElement, priority); if (object != null) { lookupElement = JavaCompletionUtil.highlightIfNeeded(qualifierType, lookupElement, object, reference); } } if ((object instanceof PsiMethod || object instanceof PsiField) && ((PsiModifierListOwner)object).hasModifierProperty(PsiModifier.STATIC)) { if (lookupElement.getLookupString().equals(((PsiMember)object).getName())) { staticMembers.put(CompletionUtil.getOriginalOrSelf((PsiModifierListOwner)object), lookupElement); } } PrioritizedLookupElement<?> prioritized = lookupElement.as(PrioritizedLookupElement.CLASS_CONDITION_KEY); if (prioritized == null || prioritized.getPriority() == 0) { zeroPriority.add(lookupElement); } else { consumer.consume(lookupElement); } }; GroovyCompletionUtil.processVariants(reference, matcher, parameters, elementConsumer); for (LookupElement element : zeroPriority) { consumer.consume(element); } zeroPriority.clear(); if (qualifierType != null) { processImplicitSpread(qualifierType, consumer, matcher, addedElements); } if (qualifier == null) { return () -> { PsiFile file = reference.getContainingFile(); if (!(file instanceof GroovyFileBaseImpl) || !(reference instanceof GrReferenceExpressionImpl)) { return; } CompleteReferenceExpression.processSpecificPlace(matcher, (GrReferenceExpressionImpl)reference, parameters, (processor) -> ((GroovyFileBaseImpl)file).processComplexImports(processor, ResolveUtilKt.initialState(true), reference), elementConsumer); for (LookupElement element : zeroPriority) { consumer.consume(element); } addStaticMembers(parameters, matcher, staticMembers, consumer).run(); }; } return EmptyRunnable.INSTANCE; }
completeReference
29,808
void (LookupElement element) { if (added.add(element)) { _consumer.consume(element); } }
consume
29,809
void (@NotNull PsiType type, @NotNull Consumer<LookupElement> consumer, @NotNull PrefixMatcher matcher, @NotNull HashSet<@NotNull LookupElement> addedElements) { var componentPair = PsiUtil.getComponentForSpreadWithDot(type); if (componentPair == null) { return; } PsiType deepComponentType = componentPair.first; int depth = componentPair.second; if (!(deepComponentType instanceof PsiClassType)) { return; } var resolveResult = ((PsiClassType)deepComponentType).resolveGenerics(); PsiClass resolvedClass = resolveResult.getElement(); if (resolvedClass == null) { return; } Set<String> existingIdentifiers = addedElements.stream().map(element -> element.getLookupString()).collect(Collectors.toSet()); for (var method : resolvedClass.getAllMethods()) { if (GroovyPropertyUtils.isSimplePropertyGetter(method)) { var lookupElement = CompleteReferenceExpression.createPropertyLookupElement(method, resolveResult.getSubstitutor(), matcher); if (lookupElement != null && !existingIdentifiers.contains(lookupElement.getLookupString())) { PsiType methodReturnType = resolveResult.getSubstitutor().substitute(method.getReturnType()); String returnTypeRepresentation = methodReturnType == null ? "?" : TypeUtils.box(methodReturnType, method).getPresentableText(); consumer.consume(lookupElement.withTypeText(StringUtil.repeat("ArrayList<", depth) + returnTypeRepresentation + StringUtil.repeat(">", depth))); } } } }
processImplicitSpread
29,810
boolean (Object object) { if (!(object instanceof LightElement && object instanceof PsiNamedElement)) return false; final String name = ((PsiNamedElement)object).getName(); if (name == null) return false; return name.contains(CompletionInitializationContext.DUMMY_IDENTIFIER_TRIMMED.trim()) || name.contains(GrDummyIdentifierProvider.DUMMY_IDENTIFIER_DECAPITALIZED.trim()); }
isLightElementDeclaredDuringCompletion
29,811
Runnable (CompletionParameters parameters, final PrefixMatcher matcher, final Map<PsiModifierListOwner, LookupElement> staticMembers, final Consumer<? super LookupElement> consumer) { final StaticMemberProcessor processor = completeStaticMembers(parameters); processor.processMembersOfRegisteredClasses(matcher::prefixMatches, (member, psiClass) -> { if (member instanceof GrAccessorMethod) { member = ((GrAccessorMethod)member).getProperty(); } member = CompletionUtil.getOriginalOrSelf(member); if (staticMembers.containsKey(member)) { return; } final String name = member.getName(); if (name == null || !matcher.prefixMatches(name)) { staticMembers.remove(member); return; } JavaGlobalMemberLookupElement element = createGlobalMemberElement(member, psiClass, true); staticMembers.put(member, element); consumer.consume(element); }); if (parameters.getInvocationCount() >= 2 && StringUtil.isNotEmpty(matcher.getPrefix())) { return () -> processor.processStaticMethodsGlobally(matcher, element -> { PsiMember member = (PsiMember)element.getObject(); if (member instanceof GrAccessorMethod) { member = ((GrAccessorMethod)member).getProperty(); } member = CompletionUtil.getOriginalOrSelf(member); if (staticMembers.containsKey(member)) { return; } staticMembers.put(member, element); consumer.consume(element); }); } return EmptyRunnable.INSTANCE; }
addStaticMembers
29,812
boolean (PsiMethod method) { if (!"next".equals(method.getName())) return false; final PsiClass containingClass = method.getContainingClass(); if (containingClass == null) return false; final PsiClass iterator = JavaPsiFacade.getInstance(method.getProject()).findClass(CommonClassNames.JAVA_UTIL_ITERATOR, method.getResolveScope()); return InheritanceUtil.isInheritorOrSelf(containingClass, iterator, true); }
checkForIterator
29,813
int (LookupElement lookupElement, PsiType qualifierType) { Object object = lookupElement.getObject(); PsiSubstitutor substitutor = null; GroovyResolveResult resolveResult = null; if (object instanceof GroovyResolveResult) { resolveResult = (GroovyResolveResult)object; substitutor = resolveResult.getSubstitutor(); object = ((GroovyResolveResult)object).getElement(); } // default groovy methods if (object instanceof GrGdkMethod && GroovyCompletionUtil.skipDefGroovyMethod((GrGdkMethod)object, substitutor, qualifierType)) { return -1; } // operator methods if (object instanceof PsiMethod && PsiUtil.OPERATOR_METHOD_NAMES.contains(((PsiMethod)object).getName()) && !checkForIterator((PsiMethod)object)) { return -3; } // accessors if there is no get, set, is prefix if (object instanceof PsiMethod && GroovyPropertyUtils.isSimplePropertyAccessor((PsiMethod)object)) { return -1; } // inaccessible elements if (resolveResult != null && !resolveResult.isAccessible()) { return -2; } return 0; }
assignPriority
29,814
StaticMemberProcessor (CompletionParameters parameters) { final PsiElement position = parameters.getPosition(); final PsiElement originalPosition = parameters.getOriginalPosition(); final StaticMemberProcessor processor = new StaticMemberProcessor(position) { @NotNull @Override protected LookupElement createLookupElement(@NotNull PsiMember member, @NotNull PsiClass containingClass, boolean shouldImport) { shouldImport |= originalPosition != null && PsiTreeUtil.isAncestor(containingClass, originalPosition, false); return createGlobalMemberElement(member, containingClass, shouldImport); } @Override protected LookupElement createLookupElement(@NotNull List<? extends PsiMethod> overloads, @NotNull PsiClass containingClass, boolean shouldImport) { shouldImport |= originalPosition != null && PsiTreeUtil.isAncestor(containingClass, originalPosition, false); return new JavaGlobalMemberLookupElement(overloads, containingClass, QualifiedMethodInsertHandler.INSTANCE, StaticImportInsertHandler.INSTANCE, shouldImport); } @Override protected boolean isAccessible(@NotNull PsiMember member) { boolean result = super.isAccessible(member); if (!result && member instanceof GrField) { GrAccessorMethod[] getters = ((GrField)member).getGetters(); return getters.length > 0 && super.isAccessible(getters[0]); } return result; } }; final PsiFile file = position.getContainingFile(); if (file instanceof GroovyFile) { for (GrImportStatement statement : ((GroovyFile)file).getImportStatements()) { if (statement.isStatic()) { GrCodeReferenceElement importReference = statement.getImportReference(); if (importReference != null) { if (!statement.isOnDemand()) { importReference = importReference.getQualifier(); } if (importReference != null) { final PsiElement target = importReference.resolve(); if (target instanceof PsiClass) { processor.importMembersOf((PsiClass)target); } } } } } } return processor; }
completeStaticMembers
29,815
LookupElement (@NotNull PsiMember member, @NotNull PsiClass containingClass, boolean shouldImport) { shouldImport |= originalPosition != null && PsiTreeUtil.isAncestor(containingClass, originalPosition, false); return createGlobalMemberElement(member, containingClass, shouldImport); }
createLookupElement
29,816
LookupElement (@NotNull List<? extends PsiMethod> overloads, @NotNull PsiClass containingClass, boolean shouldImport) { shouldImport |= originalPosition != null && PsiTreeUtil.isAncestor(containingClass, originalPosition, false); return new JavaGlobalMemberLookupElement(overloads, containingClass, QualifiedMethodInsertHandler.INSTANCE, StaticImportInsertHandler.INSTANCE, shouldImport); }
createLookupElement
29,817
boolean (@NotNull PsiMember member) { boolean result = super.isAccessible(member); if (!result && member instanceof GrField) { GrAccessorMethod[] getters = ((GrField)member).getGetters(); return getters.length > 0 && super.isAccessible(getters[0]); } return result; }
isAccessible
29,818
JavaGlobalMemberLookupElement (PsiMember member, PsiClass containingClass, boolean shouldImport) { return new JavaGlobalMemberLookupElement(member, containingClass, QualifiedMethodInsertHandler.INSTANCE, StaticImportInsertHandler.INSTANCE, shouldImport); }
createGlobalMemberElement
29,819
void (CompletionContributor contributor) { contributor.extend(CompletionType.BASIC, PlatformPatterns.psiElement(PsiElement.class), new GrMainCompletionProvider()); }
register
29,820
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull final CompletionResultSet result) { try (GroovyCompletionConsumer consumer = getCompletionConsumer(result, parameters)) { doAddCompletions(parameters, consumer); } catch (ProcessCanceledException e) { throw e; } catch (Exception e) { throw new RuntimeException(e); } }
addCompletions
29,821
void (CompletionParameters parameters, GroovyCompletionConsumer consumer) { GroovyCompletionData.addGroovyDocKeywords(parameters, consumer); PsiElement position = parameters.getPosition(); if (PlatformPatterns.psiElement().inside(false, PlatformPatterns.psiElement(PsiComment.class)).accepts(position)) { return; } GroovyCompletionData.addGroovyKeywords(parameters, consumer); addUnfinishedMethodTypeParameters(position, consumer); suggestVariableNames(position, consumer); GrReferenceElement<?> reference = findGroovyReference(position); if (reference == null) { if (parameters.getInvocationCount() >= 2) { consumer.interrupt(); addAllClasses(parameters, consumer.transform(crs -> crs.withPrefixMatcher(CompletionUtil.findJavaIdentifierPrefix(parameters))), new JavaCompletionSession(consumer.getCompletionResultSet())); } return; } if (reference.getParent() instanceof GrImportStatement && reference.getQualifier() != null) { consumer.consume(LookupElementBuilder.create("*")); } JavaCompletionSession inheritors = new JavaCompletionSession(consumer.getCompletionResultSet()); if (GroovySmartCompletionContributor.AFTER_NEW.accepts(position)) { GroovySmartCompletionContributor.generateInheritorVariants(parameters, consumer.getCompletionResultSet().getPrefixMatcher(), inheritors::addClassItem); } Runnable addSlowVariants = completeReference( parameters, reference, inheritors, consumer.getCompletionResultSet().getPrefixMatcher(), consumer.getCompletionResultSet(), lookupElement -> consumer.consume(lookupElement) ); if (reference.getQualifier() == null) { if (!GroovySmartCompletionContributor.AFTER_NEW.accepts(position)) { GroovySmartCompletionContributor.addExpectedClassMembers(parameters, consumer); } if (isClassNamePossible(position) && JavaCompletionContributor.mayStartClassName(consumer.getCompletionResultSet())) { //consumer.interrupt(); if (parameters.getInvocationCount() >= 2) { addAllClasses(parameters, consumer, inheritors); } else { JavaCompletionContributor.advertiseSecondCompletion(position.getProject(), consumer.getCompletionResultSet()); } } } consumer.fastElementsProcessed(parameters); if (GroovyCompletionUtil.isSlowCompletionEnabled()) { addSlowVariants.run(); } }
doAddCompletions
29,822
GroovyCompletionConsumer (CompletionResultSet resultSet, CompletionParameters completionParameters) { PsiElement position = completionParameters.getPosition(); for (GroovyCompletionCustomizer customizer : GroovyCompletionContributor.EP_NAME.getExtensionList()) { GroovyCompletionConsumer consumer = customizer.generateCompletionConsumer(position, resultSet); if (consumer != null) { return consumer; } } return new FastGroovyCompletionConsumer(resultSet); }
getCompletionConsumer
29,823
Result (char c, int prefixLength, Lookup lookup) { final PsiFile psiFile = lookup.getPsiFile(); if (psiFile != null && !psiFile.getViewProvider().getLanguages().contains(GroovyLanguage.INSTANCE)) return null; LookupElement item = lookup.getCurrentItem(); if (item == null) return null; if (Character.isJavaIdentifierPart(c) || c == '\'') { return Result.ADD_TO_PREFIX; } int caret = lookup.getEditor().getCaretModel().getOffset(); if (c == '.' && prefixLength == 0 && !lookup.isSelectionTouched() && caret > 0 && lookup.getEditor().getDocument().getCharsSequence().charAt(caret - 1) == '.') { return Result.HIDE_LOOKUP; } if (c == ':') { PsiFile file = lookup.getPsiFile(); PsiDocumentManager.getInstance(file.getProject()).commitDocument(lookup.getEditor().getDocument()); PsiElement element = file.findElementAt(Math.max(caret - 1, 0)); if (PsiJavaPatterns.psiElement().withParent( PsiJavaPatterns.psiElement(GrReferenceExpression.class).withParent( PsiJavaPatterns.psiElement(GrConditionalExpression.class))).accepts(element)) { return Result.SELECT_ITEM_AND_FINISH_LOOKUP; } if (item.getObject() instanceof NamedArgumentDescriptor && (MapArgumentCompletionProvider.IN_ARGUMENT_LIST_OF_CALL.accepts(element) || MapArgumentCompletionProvider.IN_LABEL.accepts(element))) { return Result.SELECT_ITEM_AND_FINISH_LOOKUP; } return Result.HIDE_LOOKUP; } if (c == '[' || c == ']' || c == ')' || c == '>') return CharFilter.Result.SELECT_ITEM_AND_FINISH_LOOKUP; if (c == '<' && item.getObject() instanceof PsiClass) return Result.SELECT_ITEM_AND_FINISH_LOOKUP; if (c == '(' && PsiKeyword.RETURN.equals(item.getLookupString())) { return Result.HIDE_LOOKUP; } return null; }
acceptChar
29,824
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull final CompletionResultSet result) { final Set<String> usedWords = new HashSet<>(); for (CompletionResult element : result.runRemainingContributors(parameters, true)) { usedWords.add(element.getLookupElement().getLookupString()); } PsiReference reference = parameters.getPosition().getContainingFile().findReferenceAt(parameters.getOffset()); if (reference == null || reference.isSoft()) { WordCompletionContributor.addWordCompletionVariants(result, parameters, usedWords); } }
addCompletions
29,825
void (@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) { if (!AFTER_NUMBER_LITERAL.accepts(parameters.getPosition())) { super.fillCompletionVariants(parameters, enrichResultSet(parameters, result)); } }
fillCompletionVariants
29,826
void (@NotNull final CompletionInitializationContext context) { final String identifier = new GrDummyIdentifierProvider(context).getIdentifier(); if (identifier != null) { context.setDummyIdentifier(identifier); } //don't eat $ from gstrings when completing previous injection ref. see IDEA-110369 PsiElement position = context.getFile().findElementAt(context.getStartOffset()); if (position!= null && position.getNode().getElementType() == GroovyTokenTypes.mDOLLAR) { context.getOffsetMap().addOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET, context.getStartOffset()); } }
beforeCompletion
29,827
CompletionResultSet (@NotNull CompletionParameters parameters, @NotNull CompletionResultSet resultSet) { for (GroovyCompletionCustomizer customizer : EP_NAME.getExtensionList()) { resultSet = customizer.customizeCompletionConsumer(parameters, resultSet); } return resultSet; }
enrichResultSet
29,828
GrNewExpression (@Nullable PsiElement position) { if (position == null) return null; final PsiElement reference = position.getParent(); if (!(reference instanceof GrCodeReferenceElement)) return null; PsiElement parent = reference.getParent(); while (parent instanceof GrCodeReferenceElement) parent = parent.getParent(); if (parent instanceof GrAnonymousClassDefinition) parent = parent.getParent(); return parent instanceof GrNewExpression ? (GrNewExpression)parent : null; }
findNewExpression
29,829
void (@NotNull InsertionContext context, @NotNull JavaPsiClassReferenceElement item) { PsiFile file = context.getFile(); Editor editor = context.getEditor(); int endOffset = editor.getCaretModel().getOffset(); if (PsiTreeUtil.findElementOfClassAtOffset(file, endOffset - 1, GrImportStatement.class, false) != null || !(file instanceof GroovyFileBase)) { AllClassesGetter.INSERT_FQN.handleInsert(context, item); return; } PsiDocumentManager.getInstance(context.getProject()).commitDocument(editor.getDocument()); PsiElement position = file.findElementAt(endOffset - 1); boolean parens = shouldInsertParentheses(position); final PsiClass psiClass = item.getObject(); if (isInVariable(position) || GroovyCompletionUtil.isInPossibleClosureParameter(position)) { Project project = context.getProject(); String qname = psiClass.getQualifiedName(); String shortName = psiClass.getName(); if (qname == null) return; PsiClass aClass = JavaPsiFacade.getInstance(project).getResolveHelper().resolveReferencedClass(shortName, position); if (aClass == null) { ((GroovyFileBase)file).addImportForClass(psiClass); return; } else if (aClass == CompletionUtil.getOriginalOrSelf(psiClass)) { return; } } AllClassesGetter.TRY_SHORTENING.handleInsert(context, item); if (parens && context.getCompletionChar() != '[') { int identifierEnd = context.getTailOffset(); GroovyPsiElement place = PsiTreeUtil.findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), GroovyPsiElement.class, false); JavaCompletionUtil.insertParentheses(context, item, false, place != null && GroovyCompletionUtil.hasConstructorParameters(psiClass, place)); if (context.getCompletionChar() == '<' || psiClass.hasTypeParameters() && context.getCompletionChar() != '(') { context.setAddCompletionChar(false); JavaCompletionUtil.promptTypeArgs(context, identifierEnd); } } }
handleInsert
29,830
boolean (PsiElement position) { final GrNewExpression newExpression = findNewExpression(position); return newExpression != null && ContainerUtil.findInstance(GroovyExpectedTypesProvider.getDefaultExpectedTypes(newExpression), PsiArrayType.class) == null; }
shouldInsertParentheses
29,831
boolean (@Nullable PsiElement position) { if (position == null) { return false; } final PsiElement parent = position.getParent(); if (parent instanceof GrVariable) { return ((GrVariable)parent).getTypeElementGroovy() == null && position == ((GrVariable)parent).getNameIdentifierGroovy(); } if (parent instanceof GrCatchClause) { return ((GrCatchClause)parent).getParameter() == null; } return false; }
isInVariable
29,832
void (CompletionContributor contributor) { contributor.extend(CompletionType.BASIC, AFTER_DOT, new GrThisSuperCompletionProvider()); }
register
29,833
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet result) { final PsiElement position = parameters.getPosition(); assert position.getParent() instanceof GrReferenceExpression; final GrReferenceExpression refExpr = ((GrReferenceExpression)position.getParent()); final GrExpression qualifier = refExpr.getQualifierExpression(); if (!(qualifier instanceof GrReferenceExpression referenceExpression)) return; final PsiElement resolved = referenceExpression.resolve(); if (!(resolved instanceof PsiClass)) return; if (parameters.getInvocationCount() > 0 && CompletionUtil.shouldShowFeature(parameters, JavaCompletionFeatures.GLOBAL_MEMBER_NAME)) { final String shortcut = KeymapUtil.getFirstKeyboardShortcutText(ActionManager.getInstance().getAction(IdeActions.ACTION_CODE_COMPLETION)); if (StringUtil.isNotEmpty(shortcut)) { result.addLookupAdvertisement(GroovyBundle.message("this.super.completion.advertisement", shortcut)); } } if (!PsiUtil.hasEnclosingInstanceInScope((PsiClass)resolved, position, false)) return; for (String keyword : THIS_SUPER) { result.addElement(LookupElementBuilder.create(keyword)); } }
addCompletions
29,834
void (CompletionContributor contributor) { final GroovyDocCompletionProvider provider = new GroovyDocCompletionProvider(); contributor.extend(CompletionType.BASIC, PsiJavaPatterns.psiElement().inside(GrDocTagValueToken.class), provider); }
register
29,835
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet result) { final PsiElement position = parameters.getPosition(); GrDocMemberReference reference = PsiTreeUtil.getParentOfType(position, GrDocMemberReference.class); if (reference == null) return; GrDocReferenceElement holder = reference.getReferenceHolder(); PsiElement resolved; if (holder != null) { GrCodeReferenceElement referenceElement = holder.getReferenceElement(); resolved = referenceElement != null ? referenceElement.resolve() : null; } else { resolved = PsiUtil.getContextClass(reference); } if (resolved instanceof PsiClass) { ResolverProcessor propertyProcessor = CompletionProcessor.createPropertyCompletionProcessor(reference); resolved.processDeclarations(propertyProcessor, ResolveState.initial(), null, reference); PsiElement[] propertyCandidates = ResolveUtil.mapToElements(propertyProcessor.getCandidates()); ResolverProcessor methodProcessor = CompletionProcessor.createPropertyCompletionProcessor(reference); resolved.processDeclarations(methodProcessor, ResolveState.initial(), null, reference); PsiElement[] methodCandidates = ResolveUtil.mapToElements(methodProcessor.getCandidates()); PsiElement[] elements = ArrayUtil.mergeArrays(propertyCandidates, methodCandidates); for (PsiElement psiElement : elements) { LookupElement element = GroovyCompletionUtil.createLookupElement((PsiNamedElement)psiElement); if (psiElement instanceof PsiMethod) { element = ((LookupElementBuilder)element).withInsertHandler(new GroovyMethodSignatureInsertHandler()); } result.addElement(element); } } }
addCompletions
29,836
void (boolean searchInheritors, final Consumer<LookupElement> results) { processMembers(results, myExpectedType.resolve(), PsiTreeUtil.getParentOfType(myPlace, GrAnnotation.class) == null, searchInheritors); }
processMembers
29,837
LookupElement (@NotNull PsiField field, @NotNull PsiClass origClass) { if (!isSuitableType(field.getType())) { return null; } return GrMainCompletionProvider.createGlobalMemberElement(field, field.getContainingClass(), false); }
createFieldElement
29,838
LookupElement (@NotNull PsiMethod method, @NotNull PsiClass origClass) { if (method.isConstructor()) return null; // TODO support suggesting constructors PsiSubstitutor substitutor = SmartCompletionDecorator.calculateMethodReturnTypeSubstitutor(method, myExpectedType); PsiType type = substitutor.substitute(method.getReturnType()); if (!isSuitableType(type)) { return null; } return GrMainCompletionProvider.createGlobalMemberElement(method, method.getContainingClass(), false); }
createMethodElement
29,839
boolean (PsiType type) { return type != null && TypesUtil.isAssignableByMethodCallConversion(myExpectedType, type, myPlace); }
isSuitableType
29,840
boolean (@NotNull PsiElement element, ProcessingContext context) { final GrTypeDefinition innerDefinition = PsiTreeUtil.getPrevSiblingOfType(element, GrTypeDefinition.class); return innerDefinition == null || innerDefinition.getContainingClass() == null || innerDefinition.getBody() != null; }
accepts
29,841
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet result) { final PsiElement position = parameters.getPosition(); final GrTypeDefinition currentClass = PsiTreeUtil.getParentOfType(position, GrTypeDefinition.class); if (currentClass != null) { addSuperMethods(currentClass, result, false); addSuperMethods(currentClass, result, true); } }
addCompletions
29,842
void (CompletionContributor contributor) { contributor.extend(CompletionType.BASIC, PLACE, new GrMethodOverrideCompletionProvider()); }
register
29,843
void (final GrTypeDefinition psiClass, CompletionResultSet completionResultSet, boolean toImplement) { final Collection<CandidateInfo> candidates = GroovyOverrideImplementExploreUtil.getMethodsToOverrideImplement(psiClass, toImplement); for (CandidateInfo candidateInfo : candidates) { final PsiMethod method = (PsiMethod)candidateInfo.getElement(); if (method.isConstructor()) continue; RowIcon icon = IconManager.getInstance().createRowIcon(2); icon.setIcon(method.getIcon(0), 0); icon.setIcon(toImplement ? AllIcons.Gutter.ImplementingMethod : AllIcons.Gutter.OverridingMethod, 1); PsiSubstitutor substitutor = candidateInfo.getSubstitutor(); String parameters = PsiFormatUtil.formatMethod(method, substitutor, PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_NAME); String visibility = VisibilityUtil.getVisibilityModifier(method.getModifierList()); String modifiers = visibility.equals(PsiModifier.PACKAGE_LOCAL) ? "" : visibility + " "; PsiType type = substitutor.substitute(method.getReturnType()); String parentClassName = psiClass == null ? "" : psiClass.getName(); String signature = modifiers + (type == null ? "" : type.getPresentableText() + " ") + method.getName(); LookupElementBuilder lookupElement = LookupElementBuilder.create(method, signature) .appendTailText(parameters, false) .appendTailText("{...}", true) .withTypeText(parentClassName) .withIcon(icon) .withInsertHandler(new GroovyMethodOverrideHandler(psiClass)); completionResultSet.addElement(lookupElement); } }
addSuperMethods
29,844
void (@NotNull InsertionContext context, @NotNull JavaGlobalMemberLookupElement item) { GroovyInsertHandler.INSTANCE.handleInsert(context, item); final PsiClass containingClass = item.getContainingClass(); context.getDocument().insertString(context.getStartOffset(), containingClass.getName() + "."); PsiDocumentManager.getInstance(containingClass.getProject()).commitDocument(context.getDocument()); final GrReferenceExpression ref = PsiTreeUtil .findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), GrReferenceExpression.class, false); if (ref != null) { ref.bindToElement(containingClass); } }
handleInsert
29,845
boolean (CompletionParameters parameters) { return PsiJavaPatterns.psiElement().withParents(GrCodeReferenceElement.class, GrAnnotation.class).accepts(parameters.getPosition()); }
suggestAnnotations
29,846
void (@NotNull final CompletionParameters parameters, @NotNull CompletionResultSet result) { JavaNoVariantsDelegator.ResultTracker tracker = new JavaNoVariantsDelegator.ResultTracker(result); result.runRemainingContributors(parameters, tracker); final boolean empty = tracker.containsOnlyPackages || suggestAnnotations(parameters); if (GrMainCompletionProvider.isClassNamePossible(parameters.getPosition()) && !JavaCompletionContributor.mayStartClassName(result)) { result.restartCompletionOnAnyPrefixChange(); } if (empty) { delegate(parameters, result, tracker.session); } else { if (parameters.getCompletionType() == CompletionType.BASIC && parameters.getInvocationCount() <= 1 && JavaCompletionContributor.mayStartClassName(result) && GrMainCompletionProvider.isClassNamePossible(parameters.getPosition()) && !MapArgumentCompletionProvider.isMapKeyCompletion(parameters)) { result = result.withPrefixMatcher(tracker.betterMatcher); suggestNonImportedClasses(parameters, result, tracker.session); } } }
fillCompletionVariants
29,847
void (CompletionParameters parameters, CompletionResultSet result, JavaCompletionSession session) { if (parameters.getCompletionType() == CompletionType.BASIC) { if (parameters.getInvocationCount() <= 1 && (JavaCompletionContributor.mayStartClassName(result) || suggestAnnotations(parameters)) && GrMainCompletionProvider.isClassNamePossible(parameters.getPosition()) && !MapArgumentCompletionProvider.isMapKeyCompletion(parameters)) { suggestNonImportedClasses(parameters, result, session); } suggestChainedCalls(parameters, result); } }
delegate
29,848
void (CompletionParameters parameters, final CompletionResultSet result, JavaCompletionSession session) { GrMainCompletionProvider.addAllClasses(parameters, element -> { JavaPsiClassReferenceElement classElement = element.as(JavaPsiClassReferenceElement.CLASS_CONDITION_KEY); if (classElement != null) { classElement.setAutoCompletionPolicy(AutoCompletionPolicy.NEVER_AUTOCOMPLETE); } result.addElement(element); }, session, result.getPrefixMatcher()); }
suggestNonImportedClasses
29,849
void (CompletionParameters parameters, CompletionResultSet result) { PsiElement position = parameters.getPosition(); PsiElement parent = position.getParent(); if (!(parent instanceof GrReferenceElement)) { return; } PsiElement qualifier = ((GrReferenceElement<?>)parent).getQualifier(); if (!(qualifier instanceof GrReferenceElement) || ((GrReferenceElement<?>)qualifier).getQualifier() != null) { return; } PsiElement target = ((GrReferenceElement<?>)qualifier).resolve(); if (target != null && !(target instanceof PsiPackage)) { return; } String fullPrefix = position.getContainingFile().getText().substring(parent.getTextRange().getStartOffset(), parameters.getOffset()); final CompletionResultSet qualifiedCollector = result.withPrefixMatcher(fullPrefix); JavaCompletionSession session = new JavaCompletionSession(result); for (final LookupElement base : suggestQualifierItems(parameters, (GrReferenceElement<?>)qualifier, session)) { final PsiType type = getPsiType(base.getObject()); if (type != null && !PsiTypes.voidType().equals(type)) { GrReferenceElement<?> ref = createMockReference(position, type, base); PsiElement refName = ref == null ? null : ref.getReferenceNameElement(); if (refName == null) continue; CompletionParameters newParams = parameters.withPosition(refName, refName.getTextRange().getStartOffset()); GrMainCompletionProvider.completeReference(newParams, ref, session, result.getPrefixMatcher(), result, element -> qualifiedCollector.addElement(new JavaChainLookupElement(base, element) { @Override protected boolean shouldParenthesizeQualifier(PsiFile file, int startOffset, int endOffset) { return false; } })); } } }
suggestChainedCalls
29,850
boolean (PsiFile file, int startOffset, int endOffset) { return false; }
shouldParenthesizeQualifier
29,851
PsiType (final Object o) { if (o instanceof ResolveResult) { return getPsiType(((ResolveResult)o).getElement()); } if (o instanceof PsiVariable) { return ((PsiVariable)o).getType(); } else if (o instanceof PsiMethod) { return ((PsiMethod)o).getReturnType(); } else if (o instanceof PsiClass psiClass) { return JavaPsiFacade.getElementFactory(psiClass.getProject()).createType(psiClass); } return null; }
getPsiType
29,852
Set<LookupElement> (CompletionParameters _parameters, GrReferenceElement<?> qualifier, JavaCompletionSession session) { String referenceName = qualifier.getReferenceName(); if (referenceName == null) { return Collections.emptySet(); } PsiElement nameElement = qualifier.getReferenceNameElement(); if (nameElement == null) { return Collections.emptySet(); } CompletionParameters parameters = _parameters.withPosition(nameElement, qualifier.getTextRange().getEndOffset()); final PrefixMatcher qMatcher = new CamelHumpMatcher(referenceName); final Set<LookupElement> variants = new LinkedHashSet<>(); GrMainCompletionProvider.completeReference(parameters, qualifier, session, qMatcher, null, element -> { if (qMatcher.prefixMatches(element)) { variants.add(element); } }); for (PsiClass aClass : PsiShortNamesCache.getInstance(qualifier.getProject()).getClassesByName(referenceName, qualifier.getResolveScope())) { variants.add(GroovyCompletionUtil.createClassLookupItem(aClass)); } if (variants.isEmpty()) { GrMainCompletionProvider.addAllClasses(parameters, element -> { if (qMatcher.prefixMatches(element)) { variants.add(element); } }, session, qMatcher); } return variants; }
suggestQualifierItems
29,853
boolean (final PsiMember member, final GroovyFile file, final PsiElement place) { final PsiManager manager = file.getManager(); PsiScopeProcessor processor = new PsiScopeProcessor() { @Override public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) { return !manager.areElementsEquivalent(element, member); } }; boolean skipStaticImports = member instanceof PsiClass; final GrImportStatement[] imports = file.getImportStatements(); final ResolveState initial = ResolveState.initial(); for (GrImportStatement anImport : imports) { if (skipStaticImports == anImport.isStatic()) continue; if (!anImport.processDeclarations(processor, initial, null, place)) return true; } return false; }
importAlreadyExists
29,854
boolean (@NotNull PsiElement element, @NotNull ResolveState state) { return !manager.areElementsEquivalent(element, member); }
execute
29,855
void (@NotNull InsertionContext context, @NotNull JavaGlobalMemberLookupElement item) { GroovyInsertHandler.INSTANCE.handleInsert(context, item); final PsiMember member = item.getObject(); PsiDocumentManager.getInstance(member.getProject()).commitDocument(context.getDocument()); final GrReferenceExpression ref = PsiTreeUtil. findElementOfClassAtOffset(context.getFile(), context.getStartOffset(), GrReferenceExpression.class, false); if (ref != null && ref.getQualifier() == null && context.getFile() instanceof GroovyFile && !importAlreadyExists(member, ((GroovyFile)context.getFile()), ref) && !PsiManager.getInstance(context.getProject()).areElementsEquivalent(ref.resolve(), member)) { ref.bindToElementViaStaticImport(member); } }
handleInsert
29,856
boolean (PsiFile file) { return GroovyCodeStyleSettings.getInstance(file).SPACE_BEFORE_CLOSURE_LBRACE; }
isSpaceBeforeClosure
29,857
boolean (Object obj, PsiElement parent) { if (parent instanceof GrAnnotationNameValuePair || parent != null && parent.getParent() instanceof GrAnnotationNameValuePair) { if (obj instanceof PsiMethod) { PsiClass aClass = ((PsiMethod)obj).getContainingClass(); if (aClass != null && aClass.isAnnotationType()) { return true; } } } return false; }
isAnnotationNameValuePair
29,858
void (final int offset, final Document document) { final CharSequence sequence = document.getCharsSequence(); int i = offset; while (i < sequence.length() && Character.isJavaIdentifierPart(sequence.charAt(i))) i++; document.deleteString(offset, i); }
handleOverwrite
29,859
void (CompletionContributor contributor) { MapKeysCompletionProvider provider = new MapKeysCompletionProvider(); contributor.extend(CompletionType.BASIC, PlatformPatterns.psiElement().withParent(PlatformPatterns.psiElement(GrReferenceExpression.class)), provider); }
register
29,860
void (@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet result) { PsiElement element = parameters.getPosition(); GrReferenceExpression expression = (GrReferenceExpression)element.getParent(); GrExpression qualifierExpression = expression.getQualifierExpression(); if (qualifierExpression == null) return; PsiType mapType = qualifierExpression.getType(); if (!InheritanceUtil.isInheritor(mapType, CommonClassNames.JAVA_UTIL_MAP)) { return; } PsiElement resolve = null; if (qualifierExpression instanceof GrMethodCall) { resolve = ((GrMethodCall)qualifierExpression).resolveMethod(); } else if (qualifierExpression instanceof GrReferenceExpression) { resolve = ((GrReferenceExpression)qualifierExpression).resolve(); } for (GroovyMapContentProvider provider : GroovyMapContentProvider.EP_NAME.getExtensions()) { GroovyMapCompletionUtil.addKeyVariants(provider, qualifierExpression, resolve, result); } if (mapType instanceof GrMapType) { for (String key : ((GrMapType)mapType).getStringKeys()) { LookupElement lookup = LookupElementBuilder.create(key); lookup = PrioritizedLookupElement.withPriority(lookup, 1); result.addElement(lookup); } } }
addCompletions
29,861
List<ClosureParameterInfo> (InsertionContext context, PsiMethod method, PsiSubstitutor substitutor, PsiElement place) { final ArrayList<ClosureDescriptor> descriptors = new ArrayList<>(); GrReferenceExpression ref = (GrReferenceExpression)place; PsiType qtype = PsiImplUtil.getQualifierType(ref); if (qtype == null) return null; GrExpression qualifier = ref.getQualifier(); if (qualifier != null) { PsiType type = qualifier.getType(); if (!(type instanceof PsiClassType)) return null; processExecutors((PsiClassType)qtype, ref, descriptors); } else { PsiElementFactory factory = JavaPsiFacade.getElementFactory(context.getProject()); for (PsiElement parent = ref.getParent(); parent != null; parent = parent.getParent()) { if (parent instanceof GrClosableBlock) { processExecutors(TypesUtil.createTypeByFQClassName(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, ref), ref, descriptors); } else if (parent instanceof GrTypeDefinition) { processExecutors(factory.createType(((GrTypeDefinition)parent), PsiType.EMPTY_ARRAY), ref, descriptors); } } } for (ClosureDescriptor descriptor : descriptors) { if (isMethodApplicable(descriptor, method, ref)) { return ContainerUtil.map(descriptor.getParameters(), d -> new ClosureParameterInfo(d.getName(), d.getType())); } } return null; }
getParameterInfos
29,862
void ( @NotNull PsiClassType qtype, @NotNull GrReferenceExpression ref, @NotNull List<ClosureDescriptor> descriptors ) { GroovyDslFileIndex.processExecutors(qtype, ref, (holder, descriptor) -> { holder.consumeClosureDescriptors(descriptor, descriptors::add); return true; }); }
processExecutors
29,863
boolean ( @NotNull ClosureDescriptor descriptor, @NotNull PsiMethod method, @NotNull GroovyPsiElement place ) { String name = descriptor.getMethodName(); if (!name.equals(method.getName())) { return false; } PsiElement typeContext; if (descriptor.getUsePlaceContextForTypes()) { typeContext = place; } else { PsiTypeParameterList typeParameterList = method.getTypeParameterList(); typeContext = typeParameterList != null ? typeParameterList : method; } List<PsiType> types = new ArrayList<>(); for (String type : descriptor.getMethodParameterTypes()) { types.add(convertToPsiType(type, typeContext)); } final boolean isConstructor = descriptor.isMethodConstructor(); final MethodSignature signature = MethodSignatureUtil.createMethodSignature( name, types.toArray(PsiType.createArray(types.size())), method.getTypeParameters(), PsiSubstitutor.EMPTY, isConstructor ); final GrSignature closureSignature = GrClosureSignatureUtil.createSignature(signature); if (method instanceof ClsMethodImpl) method = ((ClsMethodImpl)method).getSourceMirrorMethod(); final PsiParameter[] parameters = method.getParameterList().getParameters(); final PsiType[] typeArray = ContainerUtil.map( parameters, parameter -> parameter.getType(), PsiType.createArray(parameters.length) ); return GrClosureSignatureUtil.isSignatureApplicable(Collections.singletonList(closureSignature), typeArray, place); }
isMethodApplicable
29,864
PsiType (@NlsSafe String type, @NotNull PsiElement place) { return JavaPsiFacade.getElementFactory(place.getProject()).createTypeFromText(type, place); }
convertToPsiType
29,865
ThreeState (@NotNull PsiElement contextElement, @NotNull PsiFile psiFile, int offset) { if (PsiImplUtil.isLeafElementOfType(contextElement, TokenSets.STRING_LITERALS)) { PsiElement parent = contextElement.getParent(); if (parent != null) { for (PsiReference reference : parent.getReferences()) { if (!reference.isSoft() && reference.getRangeInElement().shiftRight(parent.getTextOffset()).containsOffset(offset)) { return ThreeState.NO; } } } return ThreeState.YES; } if (PsiJavaPatterns.psiElement().afterLeaf("def").accepts(contextElement)) { return ThreeState.YES; } if (contextElement.textMatches("..") || contextElement.textMatches("...")) { return ThreeState.YES; } return ThreeState.UNSURE; }
shouldSkipAutopopup
29,866
String () { return myName; }
getName
29,867
String () { return myType; }
getType
29,868
List<ClosureParameterInfo> (InsertionContext context, PsiMethod method, PsiSubstitutor substitutor, PsiElement place) { final String name = method.getName(); if (!"eachWithIndex".equals(name)) return null; if (method instanceof GrGdkMethod) method = ((GrGdkMethod)method).getStaticMethod(); final PsiClass containingClass = method.getContainingClass(); if (containingClass == null) return null; final String qname = containingClass.getQualifiedName(); if (!GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(qname)) return null; final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length != 2) return null; final PsiType type = parameters[0].getType(); final PsiType collection = substitutor.substitute(type); final PsiType iterable = getIteratedType(place, collection); if (iterable != null) { return Arrays.asList( new ClosureParameterInfo(iterable.getCanonicalText(), "entry"), new ClosureParameterInfo("int", "i") ); } if (InheritanceUtil.isInheritor(collection, CommonClassNames.JAVA_UTIL_MAP)) { final PsiType[] typeParams = ((PsiClassType)collection).getParameters(); final Project project = context.getProject(); final PsiClass entry = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_UTIL_MAP_ENTRY, place.getResolveScope()); if (entry == null) return null; final PsiClassType entryType = JavaPsiFacade.getElementFactory(project).createType(entry, typeParams); return Arrays.asList(new ClosureParameterInfo(entryType.getCanonicalText(), "entry"), new ClosureParameterInfo("int", "i")); } return Arrays.asList(new ClosureParameterInfo(collection.getCanonicalText(), "entry"), new ClosureParameterInfo("int", "i")); }
getParameterInfos
29,869
PsiType (PsiElement parent, PsiType collection) { if (parent instanceof GrReferenceExpression) { final GrExpression qualifier = ((GrReferenceExpression)parent).getQualifier(); if (qualifier != null) { return ClosureParameterEnhancer.findTypeForIteration(qualifier, parent); } } final PsiType iterable = PsiUtil.extractIterableTypeParameter(collection, true); if (iterable != null && parent instanceof GrExpression) { return PsiImplUtil.normalizeWildcardTypeByPosition(iterable, (GrExpression)parent); } else { return iterable; } }
getIteratedType
29,870
boolean (PsiElement statement) { while (statement != null && !(statement instanceof GrExpression)) { statement = statement.getLastChild(); if (statement instanceof PsiErrorElement) { statement = nearestLeftSibling(statement); } } return statement != null; }
endsWithExpression
29,871
void (Disposable disposable) { boolean previousValue = isSlowCompletionEnabled; isSlowCompletionEnabled = false; Disposer.register(disposable, () -> isSlowCompletionEnabled = previousValue); }
disableSlowCompletionElements
29,872
boolean () { return isSlowCompletionEnabled; }
isSlowCompletionEnabled
29,873
PsiElement (PsiElement elem) { elem = elem.getPrevSibling(); while (elem != null && (elem instanceof PsiWhiteSpace || elem instanceof PsiComment || GroovyTokenTypes.mNLS.equals(elem.getNode().getElementType()))) { elem = elem.getPrevSibling(); } return elem; }
nearestLeftSibling
29,874
PsiElement (PsiElement elem) { elem = PsiTreeUtil.prevLeaf(elem); while (elem != null && (elem instanceof PsiWhiteSpace || elem instanceof PsiComment || GroovyTokenTypes.mNLS.equals(elem.getNode().getElementType()))) { elem = PsiTreeUtil.prevLeaf(elem); } return elem; }
nearestLeftLeaf
29,875
boolean (PsiElement element, boolean canBeAfterBrace) { PsiElement previousLeaf = getLeafByOffset(element.getTextRange().getStartOffset() - 1, element); previousLeaf = PsiImplUtil.realPrevious(previousLeaf); if (previousLeaf != null) { if (canBeAfterBrace && GroovyTokenTypes.mLCURLY.equals(previousLeaf.getNode().getElementType())) { return true; } if (GroovyTokenTypes.mCOLON.equals(previousLeaf.getNode().getElementType()) && previousLeaf.getParent() instanceof GrLabeledStatement) { return true; } } return (previousLeaf == null || SEPARATORS.contains(previousLeaf.getNode().getElementType())); }
isNewStatement
29,876
PsiElement (int offset, PsiElement element) { if (offset < 0) { return null; } PsiElement candidate = element.getContainingFile(); while (candidate.getNode().getFirstChildNode() != null) { candidate = candidate.findElementAt(offset); } return candidate; }
getLeafByOffset
29,877
boolean (PsiElement context) { return isInTypeDefinitionBody(context) && isNewStatement(context, true); }
asSimpleVariable
29,878
boolean (PsiElement context) { return (context.getParent() instanceof GrCodeReferenceElement && context.getParent().getParent() instanceof GrClassTypeElement && context.getParent().getParent().getParent() instanceof GrTypeDefinitionBody) || context.getParent() instanceof GrTypeDefinitionBody; }
isInTypeDefinitionBody
29,879
boolean (PsiElement context) { if (context.getParent() instanceof GrReferenceExpression) { PsiElement parent = context.getParent().getParent(); while (parent instanceof GrStatement) { parent = parent.getParent(); } if ((parent instanceof GrControlFlowOwner || parent instanceof GrCaseSection) && isNewStatement(context, true)) { return true; } } return context.getParent() instanceof GrTypeDefinitionBody && isNewStatement(context, true); }
asVariableInBlock
29,880
boolean (PsiElement context) { return context.getParent() instanceof GrReferenceElement && context.getParent().getParent() instanceof GrTypeElement && context.getParent().getParent().getParent() instanceof GrMethod && context.getParent().getParent().getParent().getParent() instanceof GrTypeDefinitionBody && context.getTextRange().getStartOffset() == context.getParent().getParent().getParent().getParent().getTextRange().getStartOffset(); }
asTypedMethod
29,881
List<LookupElement> (GroovyResolveResult[] candidates, boolean afterNew, PrefixMatcher matcher, PsiElement position) { List<LookupElement> result = new ArrayList<>(); for (GroovyResolveResult candidate : candidates) { result.addAll(createLookupElements(candidate, afterNew, matcher, position)); ProgressManager.checkCanceled(); } return result; }
getCompletionVariants
29,882
List<LookupElement> (List<? extends GroovyResolveResult> candidates, boolean afterNew, PrefixMatcher matcher, PsiElement position) { List<LookupElement> result = new ArrayList<>(); for (GroovyResolveResult candidate : candidates) { result.addAll(createLookupElements(candidate, afterNew, matcher, position)); ProgressManager.checkCanceled(); } return result; }
getCompletionVariants
29,883
boolean (PrefixMatcher matcher, PsiMethod element, String importedName) { return GroovyPropertyUtils.isSimplePropertySetter(element) && matcher.prefixMatches(GroovyPropertyUtils.getSetterName(importedName)); }
setterMatches
29,884
boolean (PrefixMatcher matcher, PsiMethod element, String importedName) { return GroovyPropertyUtils.isSimplePropertyGetter(element) && (matcher.prefixMatches(GroovyPropertyUtils.getGetterNameNonBoolean(importedName)) || PsiTypes.booleanType().equals(element.getReturnType()) && matcher.prefixMatches(GroovyPropertyUtils.getGetterNameBoolean(importedName))); }
getterMatches
29,885
LookupElement (PsiClass psiClass) { assert psiClass.isValid(); return AllClassesGetter.createLookupItem(psiClass, new GroovyClassNameInsertHandler()); }
createClassLookupItem
29,886
LookupElement (PsiNamedElement o) { return setupLookupBuilder(o, PsiSubstitutor.EMPTY, LookupElementBuilder.create(o, o.getName()), null); }
createLookupElement
29,887
LookupElement (PsiElement element, PsiSubstitutor substitutor, LookupElementBuilder builder, @Nullable PsiElement position) { builder = builder.withIcon(element.getIcon(Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS)) .withInsertHandler(GroovyInsertHandler.INSTANCE); if (element instanceof PsiModifierListOwner && ((PsiModifierListOwner)element).hasAnnotation(CommonClassNames.JAVA_LANG_DEPRECATED)) { builder = builder.strikeout(); } builder = setTailText(element, builder, substitutor); builder = setTypeText(element, builder, substitutor, position); return builder; }
setupLookupBuilder
29,888
LookupElementBuilder (PsiElement element, LookupElementBuilder builder, PsiSubstitutor substitutor) { if (element instanceof PsiMethod) { PsiClass aClass = ((PsiMethod)element).getContainingClass(); if (aClass != null && aClass.isAnnotationType()) { return builder; } builder = builder.withTailText(PsiFormatUtil.formatMethod((PsiMethod)element, substitutor, PsiFormatUtilBase.SHOW_PARAMETERS, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_TYPE)); } else if (element instanceof PsiClass psiClass) { String tailText = getPackageText((PsiClass)element); if ((substitutor == null || substitutor.getSubstitutionMap().isEmpty()) && psiClass.getTypeParameters().length > 0) { tailText = "<" + StringUtil.join(psiClass.getTypeParameters(), psiTypeParameter -> psiTypeParameter.getName(), "," + (showSpaceAfterComma(psiClass) ? " " : "")) + ">" + tailText; } builder = builder.withTailText(tailText, true); } return builder; }
setTailText
29,889
String (PsiClass psiClass) { @NonNls String packageName = PsiFormatUtil.getPackageDisplayName(psiClass); return " (" + packageName + ")"; }
getPackageText
29,890
boolean (PsiClass element) { return CodeStyle.getLanguageSettings(element.getContainingFile(), GroovyLanguage.INSTANCE).SPACE_AFTER_COMMA; }
showSpaceAfterComma
29,891
LookupElementBuilder (PsiElement element, LookupElementBuilder builder, PsiSubstitutor substitutor, @Nullable PsiElement position) { PsiType type = null; if (element instanceof GrVariable) { type = TypeInferenceHelper.getVariableTypeInContext(position, (GrVariable)element); } else if (element instanceof PsiVariable) { type = ((PsiVariable)element).getType(); } else if (element instanceof PsiMethod) { type = substitutor.substitute(((PsiMethod)element).getReturnType()); } else if (element instanceof GroovyProperty) { type = ((GroovyProperty)element).getPropertyType(); } return type != null ? builder.withTypeText(type.getPresentableText()) : builder; }
setTypeText
29,892
boolean (@NotNull PsiClass clazz, @NotNull PsiElement place) { final List<PsiMethod> constructors = getAllConstructors(clazz, place); final List<PsiMethod> accessibleParameterlessConstructors = new SmartList<>(); final List<PsiMethod> inaccessibleConstructors = new SmartList<>(); for (PsiMethod constructor : constructors) { if (PsiUtil.isAccessible(place, constructor)) { if (constructor.hasParameters()) { return true; } accessibleParameterlessConstructors.add(constructor); } else { inaccessibleConstructors.add(constructor); } } return accessibleParameterlessConstructors.isEmpty() && ( ContainerUtil.or(inaccessibleConstructors, constructor -> constructor.hasParameters()) || ContainerUtil.or(clazz.getAllMethods(), method -> GroovyPropertyUtils.isSimplePropertySetter(method)) ); }
hasConstructorParameters
29,893
int (Editor editor, int oldTail, boolean space_within_cast_parentheses) { int offset = -1; final HighlighterIterator iterator = editor.getHighlighter().createIterator(oldTail); while (!iterator.atEnd()) { final IElementType tokenType = iterator.getTokenType(); if (TokenSets.WHITE_SPACES_OR_COMMENTS.contains(tokenType)) { iterator.advance(); continue; } if (tokenType == GroovyTokenTypes.mRPAREN) { offset = iterator.getEnd(); } break; } if (offset != -1) return offset; offset = oldTail; if (space_within_cast_parentheses) { offset = TailType.insertChar(editor, oldTail, ' '); } return TailType.insertChar(editor, offset, ')'); }
addRParenth
29,894
boolean (GrGdkMethod gdkMethod, PsiSubstitutor substitutor, @Nullable PsiType type) { if (type == null) return false; String name = gdkMethod.getStaticMethod().getName(); final PsiType baseType = gdkMethod.getReceiverType(); if (!TypeConversionUtil.erasure(baseType).equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) return false; final PsiType substituted = substitutor != null ? substitutor.substitute(baseType) : baseType; if (GdkMethodUtil.COLLECTION_METHOD_NAMES.contains(name)) { return !(type instanceof PsiArrayType || InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_LANG_ITERABLE) || substituted instanceof PsiArrayType || InheritanceUtil.isInheritor(substituted, CommonClassNames.JAVA_LANG_ITERABLE)); } if (GdkMethodUtil.isWithName(name)) return false; return true; }
skipDefGroovyMethod
29,895
boolean (PsiElement position) { PsiElement prev = PsiUtil.getPreviousNonWhitespaceToken(position); if (prev instanceof PsiErrorElement) prev = PsiUtil.getPreviousNonWhitespaceToken(prev); if (prev == null || prev.getNode().getElementType() != GroovyTokenTypes.mQUESTION) return false; final PsiElement pprev = PsiUtil.getPreviousNonWhitespaceToken(prev); if (pprev == null) return false; final IElementType t = pprev.getNode().getElementType(); return t == GroovyTokenTypes.mLT || t == GroovyTokenTypes.mCOMMA; }
isWildcardCompletion
29,896
boolean (PsiElement context) { final PsiElement leaf = getLeafByOffset(context.getTextRange().getStartOffset() - 1, context); if (leaf != null && isNewStatement(context, false)) { PsiElement parent = leaf.getParent(); if (parent instanceof GroovyFile) { return true; } } return false; }
isNewStatementInScript
29,897
boolean (PsiElement context) { if (context.getParent() instanceof GrCodeReferenceElement) { PsiElement pparent = context.getParent().getParent(); if (pparent instanceof GrNewExpression) return true; } return false; }
isReferenceElementInNewExpr
29,898
boolean (PsiElement context) { return context.getParent() instanceof GrCodeReferenceElement && !(context.getParent().getParent() instanceof GrImportStatement) && !(context.getParent().getParent() instanceof GrPackageDefinition) && !(context.getParent().getParent() instanceof GrNewExpression); }
isCodeReferenceElementApplicableToModifierCompletion
29,899
boolean (PsiElement context) { return (context.getParent() instanceof GrParameter && ((GrParameter)context.getParent()).getTypeElementGroovy() == null); }
isTypelessParameter