Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
33,500 | boolean (GrExpression expr) { PsiElement parent = PsiTreeUtil.skipParentsOfType(expr, GrParenthesizedExpression.class); return isPlusPlusOrMinusMinus(parent); } | isUsedInIncOrDec |
33,501 | boolean (@Nullable PsiElement parent) { if (parent instanceof GrUnaryExpression) { IElementType tokenType = ((GrUnaryExpression)parent).getOperationTokenType(); return tokenType == GroovyTokenTypes.mINC || tokenType == GroovyTokenTypes.mDEC; } return false; } | isPlusPlusOrMinusMinus |
33,502 | void (@NotNull GrReferenceExpression refExpr, @NotNull PsiMember member, String name) { assert refExpr.getQualifierExpression() == null; final PsiClass clazz = member.getContainingClass(); assert clazz != null; if (member.hasModifierProperty(PsiModifier.STATIC)) { final GrReferenceExpression newRefExpr = GroovyPsiElementFactory.getInstance(member.getProject()) .createReferenceExpressionFromText(clazz.getQualifiedName() + "." + name); refExpr.replace(newRefExpr); } else { final PsiClass containingClass = PsiTreeUtil.getParentOfType(refExpr, PsiClass.class); if (member.getManager().areElementsEquivalent(containingClass, clazz)) { final GrReferenceExpression newRefExpr = GroovyPsiElementFactory.getInstance(member.getProject()) .createReferenceExpressionFromText("this." + name); refExpr.replace(newRefExpr); } else { final GrReferenceExpression newRefExpr = GroovyPsiElementFactory.getInstance(member.getProject()) .createReferenceExpressionFromText(clazz.getName() + ".this." + name); refExpr.replace(newRefExpr); } } } | qualifyMemberReference |
33,503 | PsiElement (@Nullable PsiElement element, boolean up) { if (element == null) return null; if (up) { PsiElement parent; while ((parent = element.getParent()) instanceof GrParenthesizedExpression) { element = parent; } } else { while (element instanceof GrParenthesizedExpression) { element = ((GrParenthesizedExpression)element).getOperand(); } } return element; } | skipParentheses |
33,504 | PsiElement (@NotNull PsiElement element, boolean up) { PsiElement res = skipParentheses(element, up); return res == null ? element : res; } | skipParenthesesIfSensibly |
33,505 | PsiElement (GrNamedArgument otherNamedArgument, String argumentName) { PsiElement parent = otherNamedArgument.getParent(); if (!(parent instanceof GrNamedArgumentsOwner)) return null; GrNamedArgument namedArgument = ((GrNamedArgumentsOwner)parent).findNamedArgument(argumentName); if (namedArgument == null) return null; return namedArgument.getExpression(); } | getNamedArgumentValue |
33,506 | PsiClass (@NotNull PsiClass aClass) { PsiFile file = aClass.getContainingFile(); if (file == null) return aClass; PsiFile originalFile = file.getOriginalFile(); if (originalFile == file) return aClass; if (!(originalFile instanceof PsiClassOwner)) return aClass; String name = aClass.getName(); if (name == null) return aClass; for (PsiClass originalClass : ((PsiClassOwner)originalFile).getClasses()) { if (name.equals(originalClass.getName())) { return originalClass; } } return aClass; } | getOriginalClass |
33,507 | void (PsiMember owner, PsiElement place) { PsiModifierList modifierList = owner.getModifierList(); LOG.assertTrue(modifierList != null); final String visibilityModifier = VisibilityUtil.getVisibilityModifier(modifierList); int index; for (index = 0; index < visibilityModifiers.length; index++) { String modifier = visibilityModifiers[index]; if (modifier.equals(visibilityModifier)) break; } for (; index < visibilityModifiers.length && !isAccessible(place, owner); index++) { @PsiModifier.ModifierConstant String modifier = visibilityModifiers[index]; com.intellij.psi.util.PsiUtil.setModifierProperty(owner, modifier, true); } } | escalateVisibility |
33,508 | int (@NotNull GrCall call, @NotNull PsiElement argument) { GrArgumentList argumentList = call.getArgumentList(); if (argumentList == null) return -1; GrExpression[] expressionArguments = argumentList.getExpressionArguments(); for (int i = 0; i < expressionArguments.length; i++) { if (argument.equals(expressionArguments[i])) { int res = i; if (argumentList.getNamedArguments().length > 0) { res++; // first argument is map defined by named arguments } return res; } } if (argument instanceof GrClosableBlock) { GrClosableBlock[] closureArgs = call.getClosureArguments(); for (int i = 0; i < closureArgs.length; i++) { if (argument.equals(closureArgs[i])) { int res = i + expressionArguments.length; if (argumentList.getNamedArguments().length > 0) { res++; // first argument is map defined by named arguments } return res; } } } return -1; } | getArgumentIndex |
33,509 | GrExpression[] (@NotNull GrCall call) { GrArgumentList argumentList = call.getArgumentList(); if (argumentList == null) return GrExpression.EMPTY_ARRAY; GrClosableBlock[] closureArguments = call.getClosureArguments(); GrExpression[] expressionArguments = argumentList.getExpressionArguments(); GrNamedArgument[] namedArguments = argumentList.getNamedArguments(); int length = expressionArguments.length + closureArguments.length; int k = 0; if (namedArguments.length > 0) { length++; k = 1; } GrExpression[] res = new GrExpression[length]; for (GrExpression expressionArgument : expressionArguments) { res[k++] = expressionArgument; } for (GrClosableBlock closureArgument : closureArguments) { res[k++] = closureArgument; } return res; } | getAllArguments |
33,510 | GrNamedArgument[] (@NotNull GrCall grCall) { GrNamedArgument[] res = grCall.getNamedArguments(); if (res.length > 0) return res; GrExpression[] arguments = grCall.getExpressionArguments(); if (arguments.length == 0) return GrNamedArgument.EMPTY_ARRAY; PsiElement firstArg = arguments[0]; if (!(firstArg instanceof GrListOrMap)) return GrNamedArgument.EMPTY_ARRAY; return ((GrListOrMap)firstArg).getNamedArguments(); } | getFirstMapNamedArguments |
33,511 | boolean (@Nullable PsiElement expr) { if (!(expr instanceof GrStatement)) return false; final PsiElement parent = expr.getParent(); if (parent instanceof GrControlFlowOwner || parent instanceof GrCaseSection) return true; if (parent instanceof GrLabeledStatement) return true; if (parent instanceof GrIfStatement && (expr == ((GrIfStatement)parent).getThenBranch() || expr == ((GrIfStatement)parent).getElseBranch())) { return true; } if (parent instanceof GrWhileStatement && expr == ((GrWhileStatement)parent).getBody()) { return true; } return false; } | isExpressionStatement |
33,512 | GrMethodCall (GrNamedArgument namedArgument) { GrCall res = getCallByNamedParameter(namedArgument); if (res instanceof GrMethodCall) return (GrMethodCall)res; return null; } | getMethodCallByNamedParameter |
33,513 | GrCall (GrNamedArgument namedArgument) { PsiElement parent = namedArgument.getParent(); PsiElement eMethodCall; if (parent instanceof GrArgumentList) { eMethodCall = parent.getParent(); } else { if (!(parent instanceof GrListOrMap)) return null; PsiElement eArgumentList = parent.getParent(); if (!(eArgumentList instanceof GrArgumentList argumentList)) return null; if (argumentList.getNamedArguments().length > 0) return null; if (argumentList.getExpressionArgumentIndex((GrListOrMap)parent) != 0) return null; eMethodCall = eArgumentList.getParent(); } if (!(eMethodCall instanceof GrCall)) return null; return (GrCall)eMethodCall; } | getCallByNamedParameter |
33,514 | String (@NotNull PsiAnnotation annotation, final String attributeName, String defaultValue) { PsiAnnotationMemberValue value = annotation.findAttributeValue(attributeName); if (value instanceof GrExpression) { Object o = GroovyConstantExpressionEvaluator.evaluate((GrExpression)value); if (o instanceof String) { return (String)o; } } return defaultValue; } | getAnnoAttributeValue |
33,515 | boolean (@NotNull PsiAnnotation annotation, final String attributeName, boolean defaultValue) { PsiAnnotationMemberValue value = annotation.findAttributeValue(attributeName); if (value instanceof GrExpression) { Object o = GroovyConstantExpressionEvaluator.evaluate((GrExpression)value); if (o instanceof Boolean) { return (Boolean)o; } } return defaultValue; } | getAnnoAttributeValue |
33,516 | boolean (PsiElement expr) { while (expr.getParent() instanceof GrParenthesizedExpression) expr = expr.getParent(); PsiElement parent = expr.getParent(); if (parent instanceof GrBinaryExpression || parent instanceof GrUnaryExpression || parent instanceof GrConditionalExpression || parent instanceof GrAssignmentExpression || parent instanceof GrInstanceOfExpression || parent instanceof GrSafeCastExpression || parent instanceof GrTuple || parent instanceof GrArgumentList || parent instanceof GrReturnStatement || parent instanceof GrAssertStatement || parent instanceof GrThrowStatement || parent instanceof GrSwitchStatement || parent instanceof GrVariable || parent instanceof GrWhileStatement) { return true; } if (parent instanceof GrReferenceExpression) { if (ResolveUtil.isClassReference(parent)) { parent = parent.getParent(); } if (parent instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression)parent).resolve(); if (resolved instanceof PsiMember) { PsiClass containingClass = ((PsiMember)resolved).getContainingClass(); return containingClass != null && JAVA_LANG_CLASS.equals(containingClass.getQualifiedName()); } } return true; } if (parent instanceof GrTraditionalForClause forClause) { return expr == forClause.getCondition(); } return isReturnStatement(expr); } | isExpressionUsed |
33,517 | boolean (@NotNull PsiElement statement) { final GrControlFlowOwner controlFlowOwner = ControlFlowUtils.findControlFlowOwner(statement); if (controlFlowOwner instanceof GrOpenBlock) { final PsiElement controlFlowOwnerParent = controlFlowOwner.getParent(); if (controlFlowOwnerParent instanceof GrMethod && ((GrMethod)controlFlowOwnerParent).isConstructor()) { return false; } else if (controlFlowOwnerParent instanceof PsiMethod && PsiTypes.voidType().equals(((PsiMethod)controlFlowOwnerParent).getReturnType())) { return false; } } return ControlFlowUtils.collectReturns(controlFlowOwner, true).contains(statement); } | isReturnStatement |
33,518 | PsiClass (@Nullable PsiElement element) { PsiClass domainClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); if (domainClass == null) return null; while (true) { PsiClass c = domainClass.getContainingClass(); if (c == null) return domainClass; domainClass = c; } } | getContainingNotInnerClass |
33,519 | ResolveResult (GrExpression expression) { if (isThisOrSuperRef(expression)) return EmptyGroovyResolveResult.INSTANCE; PsiType type = expression.getType(); if (type instanceof PsiClassType) { return ((PsiClassType)type).resolveGenerics(); } if (type == null && expression instanceof GrReferenceExpression) { GroovyResolveResult resolveResult = ((GrReferenceExpression)expression).advancedResolve(); if (resolveResult.getElement() instanceof PsiClass) { return resolveResult; } } return EmptyGroovyResolveResult.INSTANCE; } | getAccessObjectClass |
33,520 | boolean (@Nullable PsiElement element, @NotNull String name) { if (!(element instanceof GrReferenceExpression ref)) return false; return !ref.isQualified() && name.equals(ref.getReferenceName()); } | isReferenceWithoutQualifier |
33,521 | boolean (@NotNull GrField field) { final PsiClass clazz = field.getContainingClass(); if (clazz == null) return false; if (clazz.isInterface() && !GrTraitUtil.isTrait(clazz)) return false; final GrModifierList modifierList = field.getModifierList(); return modifierList == null || !modifierList.hasExplicitVisibilityModifiers(); } | isProperty |
33,522 | boolean (@NotNull PsiMethod constructor) { LOG.assertTrue(constructor.isConstructor()); final PsiParameter[] parameters = constructor.getParameterList().getParameters(); for (PsiParameter parameter : parameters) { if (!(parameter instanceof GrParameter && ((GrParameter)parameter).isOptional())) return true; } return false; } | isConstructorHasRequiredParameters |
33,523 | boolean (PsiElement context) { return getArgumentsList(context) != null; } | isInMethodCallContext |
33,524 | List<GrImportStatement> (final GroovyFile file) { final List<GrImportStatement> oldImports = new ArrayList<>(); for (GrImportStatement statement : file.getImportStatements()) { if (!ErrorUtil.containsError(statement)) { oldImports.add(statement); } } return oldImports; } | getValidImportStatements |
33,525 | boolean (@NotNull GrReferenceExpression expression) { return CompileStaticUtil.isCompileStatic(expression) || GrStaticChecker.isPropertyAccessInStaticMethod(expression); } | isInStaticCompilationContext |
33,526 | boolean (@Nullable PsiElement expr) { if (!(expr instanceof GrReferenceExpression refExpr)) { return false; } if (!expr.isValid()) { return false; } if (refExpr.isQualified()) { return false; } String referenceName = refExpr.getReferenceName(); if (referenceName == null) { return false; } List<PsiAnnotation> newifyAnnotations = NewifyMemberContributor.getNewifyAnnotations(expr); for (PsiAnnotation anno : newifyAnnotations) { if (NewifyMemberContributor.matchesPattern(referenceName, anno)) { return true; } List<PsiClass> selectedClasses = GrAnnotationUtil.getClassArrayValue(anno, "value", true); if (selectedClasses.stream().anyMatch(clazz -> referenceName.equals(clazz.getName()))) { return true; } } return false; } | isNewified |
33,527 | boolean (@NotNull GroovyResolveResult result) { if (result instanceof GroovyConstructorResult && ((GroovyConstructorResult)result).isMapConstructor()) return true; if (!(result instanceof GroovyConstructorResult) && result.getElement() instanceof PsiMethod && !((PsiMethod)result.getElement()).hasParameters()) return true; PsiElement method = result.getElement(); if (method instanceof PsiMethod) { PsiParameter[] parameters = ((PsiMethod)method).getParameterList().getParameters(); PsiClass containingClass = ((PsiMethod)method).getContainingClass(); if (containingClass == null) return false; GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(method.getProject()); if (parameters.length <= 2 && containingClass.hasAnnotation(GROOVY_TRANSFORM_MAP_CONSTRUCTOR)) { if (parameters.length == 2 && !(parameters[0] instanceof ConstructorAnnotationsProcessor.EnclosingClassParameter)) { return false; } PsiType lastParameterType = parameters[parameters.length - 1].getType(); return TypesUtil.isAssignableByMethodCallConversion(lastParameterType, factory.createTypeByFQClassName(JAVA_UTIL_MAP), method); } } return false; } | isTrustedMapConstructorResult |
33,528 | PsiType (GrForInClause forIn) { GrExpression iterated = forIn.getIteratedExpression(); if (iterated == null) return null; return ClosureParameterEnhancer.findTypeForIteration(iterated, forIn); } | extractIteratedType |
33,529 | boolean (@Nullable PsiElement expression) { return isThisOrSuperRef(expression, GroovyTokenTypes.kTHIS, false); } | isThisReference |
33,530 | boolean (@Nullable PsiElement expression) { return isThisOrSuperRef(expression, GroovyTokenTypes.kSUPER, true); } | isSuperReference |
33,531 | boolean (PsiElement expression, IElementType token, boolean superClassAccepted) { if (!(expression instanceof GrReferenceExpression ref)) return false; PsiElement nameElement = ref.getReferenceNameElement(); if (nameElement == null) return false; IElementType type = nameElement.getNode().getElementType(); if (type != token) return false; GrExpression qualifier = ref.getQualifier(); if (qualifier == null) { return true; } else { PsiElement resolved = ref.resolve(); if (resolved instanceof PsiClass) { if (hasEnclosingInstanceInScope(((PsiClass)resolved), ref, superClassAccepted)) return true; if (superClassAccepted && GrTraitUtil.isTrait((PsiClass)resolved) && scopeClassImplementsTrait(((PsiClass)resolved), ref)) return true; } return false; } } | isThisOrSuperRef |
33,532 | boolean (@NotNull final PsiClass trait, @NotNull final PsiElement place) { GrTypeDefinition scopeClass = PsiTreeUtil.getParentOfType(place, GrTypeDefinition.class, true); return scopeClass != null && ContainerUtil.find(scopeClass.getSuperTypes(), type -> place.getManager().areElementsEquivalent(type.resolve(), trait)) != null; } | scopeClassImplementsTrait |
33,533 | boolean (@Nullable PsiElement qualifier) { return qualifier instanceof GrReferenceExpression && (isThisReference(qualifier) || isSuperReference(qualifier)); } | isThisOrSuperRef |
33,534 | boolean (PsiElement qualifier) { if (isThisReference(qualifier)) { GrReferenceExpression ref = (GrReferenceExpression)qualifier; PsiElement resolved = ref.resolve(); if (!(resolved instanceof PsiClass)) return false; return hasEnclosingInstanceInScope((PsiClass)resolved, qualifier, false); } return false; } | isInstanceThisRef |
33,535 | boolean (@Nullable PsiElement e) { return e != null && PsiImplUtil.isWhiteSpaceOrNls(e) && (e.getText().indexOf('\n') >= 0 || e.getText().indexOf('\r') >= 0); } | isLineFeed |
33,536 | boolean (GroovyResolveResult[] candidates) { return candidates.length == 1 && candidates[0].getElement() instanceof GrBindingVariable; } | isSingleBindingVariant |
33,537 | GrConstructorInvocation (@NotNull GrMethod constructor) { assert constructor.isConstructor(); final GrOpenBlock body = constructor.getBlock(); if (body == null) return null; final GrStatement[] statements = body.getStatements(); if (statements.length > 0 && statements[0] instanceof GrConstructorInvocation) { return ((GrConstructorInvocation)statements[0]); } else { return null; } } | getConstructorInvocation |
33,538 | boolean (@Nullable PsiElement element) { if (!(element instanceof PsiMethod)) return false; final PsiMethod method = element instanceof GrGdkMethod ? ((GrGdkMethod)element).getStaticMethod() : (PsiMethod)element; final PsiClass aClass = method.getContainingClass(); if (aClass == null) return false; final String qname = aClass.getQualifiedName(); return DEFAULT_INSTANCE_EXTENSIONS.contains(qname) || DEFAULT_STATIC_EXTENSIONS.contains(qname); } | isDGMMethod |
33,539 | boolean (@Nullable GrExpression expression) { if (!(expression instanceof GrMethodCall)) { return false; } final PsiElement element = ((GrMethodCall)expression).advancedResolve().getElement(); if (!(element instanceof PsiMethod)) { return false; } return PsiTypes.voidType().equals(((PsiMethod)element).getReturnType()); } | isVoidMethodCall |
33,540 | boolean (@NotNull PsiMethod method) { if (PsiTypes.voidType().equals(method.getReturnType())) { return true; } if (method instanceof GrMethod && ((GrMethod)method).getReturnTypeElementGroovy() == null) { GrOpenBlock block = ((GrMethod)method).getBlock(); if (block != null && isBlockReturnVoid(block)) { return true; } } return false; } | isVoidMethod |
33,541 | boolean (@NotNull final GrCodeBlock block) { return CachedValuesManager.getCachedValue(block, () -> CachedValueProvider.Result.create(ControlFlowUtils.visitAllExitPoints(block, new ControlFlowUtils.ExitPointVisitor() { @Override public boolean visitExitPoint(Instruction instruction, @Nullable GrExpression returnValue) { return !(returnValue instanceof GrLiteral); } }), PsiModificationTracker.MODIFICATION_COUNT)); } | isBlockReturnVoid |
33,542 | boolean (Instruction instruction, @Nullable GrExpression returnValue) { return !(returnValue instanceof GrLiteral); } | visitExitPoint |
33,543 | boolean (PsiElement l, PsiElement r) { if (!l.getText().equals(r.getText())) return false; if (l.getNode().getElementType() != r.getNode().getElementType()) return false; final PsiElement[] lChildren = l.getChildren(); final PsiElement[] rChildren = r.getChildren(); if (lChildren.length != rChildren.length) return false; for (int i = 0; i < rChildren.length; i++) { if (!checkPsiElementsAreEqual(lChildren[i], rChildren[i])) return false; } return true; } | checkPsiElementsAreEqual |
33,544 | boolean (GrReferenceExpression referenceExpression) { return referenceExpression.getParent() instanceof GrCall; } | isCall |
33,545 | boolean (@Nullable PsiElement variable) { return variable instanceof GrVariable && !(variable instanceof GrField || variable instanceof GrParameter); } | isLocalVariable |
33,546 | boolean (@Nullable PsiElement variable) { return variable instanceof GrVariable && !(variable instanceof GrField); } | isLocalOrParameter |
33,547 | PsiElement (PsiElement e) { PsiElement next = PsiTreeUtil.prevLeaf(e); while (next != null && next.getNode().getElementType() == TokenType.WHITE_SPACE) next = PsiTreeUtil.prevLeaf(next); return next; } | getPreviousNonWhitespaceToken |
33,548 | Object (@Nullable GrArgumentLabel label) { if (label == null) return null; final PsiElement element = label.getNameElement(); if (element instanceof GrExpression) { final Object value = JavaPsiFacade.getInstance(label.getProject()).getConstantEvaluationHelper().computeConstantExpression(element); if (value != null) return value; } final IElementType elemType = element.getNode().getElementType(); if (GroovyTokenTypes.mIDENT == elemType || TokenSets.KEYWORDS.contains(elemType)) { return element.getText(); } return GrLiteralImpl.getLiteralValue(element); } | getLabelValue |
33,549 | boolean (@NotNull GrCall call) { if (CompileStaticUtil.isCompileStatic(call) || call.hasClosureArguments()) { return false; } var argumentList = call.getArgumentList(); if (argumentList == null || !argumentList.isEmpty()) { return false; } GroovyResolveResult result = call.advancedResolve(); if (!(result instanceof GroovyMethodResult)) { return false; } GroovyMethodCandidate candidate = ((GroovyMethodResult)result).getCandidate(); if (candidate == null) { return false; } return candidate.getArgumentMapping() instanceof NullArgumentMapping<?>; } | isEligibleForInvocationWithNull |
33,550 | boolean (@NotNull GrSwitchElement switchElement) { if (!(switchElement instanceof GrSwitchStatement)) return false; GrCaseSection[] sections = switchElement.getCaseSections(); return ContainerUtil.and(sections, elem -> elem.getColon() != null); } | isPlainSwitchStatement |
33,551 | boolean (GrReferenceElement ref, String expected) { final String actual = ref.getReferenceName(); if (expected.equals(actual)) { return true; } if (ref.getQualifier() != null) { return false; } final PsiFile file = ref.getContainingFile(); if (!(file instanceof GroovyFile)) { return false; } MultiMap<String, String> data = getAliases((GroovyFile)file); Collection<String> aliases = data.get(expected); return aliases.contains(actual); } | acceptName |
33,552 | boolean (@NotNull PsiModifierListOwner member, @NotNull PsiElement place, @Nullable PsiElement resolveContext, boolean filterStaticAfterInstanceQualifier) { if (!(member instanceof PsiMember)) return true; if (member instanceof PsiMethod && ((PsiMethod)member).isConstructor()) return true; if (!(place instanceof GrReferenceExpression)) return true; if (member instanceof PsiClass && PsiTreeUtil.isAncestor(member, place, false)) return true; GrExpression qualifier = ((GrReferenceExpression)place).getQualifierExpression(); final PsiClass containingClass = getContainingClass((PsiMember)member); if (qualifier != null) { return checkQualified(member, place, filterStaticAfterInstanceQualifier, qualifier, containingClass); } else { return checkNonQualified(member, place, resolveContext, containingClass); } } | isStaticsOK |
33,553 | boolean (PsiModifierListOwner member, PsiElement place, PsiElement resolveContext, PsiClass containingClass) { if (containingClass == null) return true; if (member instanceof GrVariable && !(member instanceof GrField)) return true; if (member.hasModifierProperty(PsiModifier.STATIC)) return true; if (CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())) return true; if (resolveContext != null) { PsiElement stopAt = PsiTreeUtil.findCommonParent(place, resolveContext); while (place != null && place != stopAt && !(place instanceof GrMember)) { if (place instanceof PsiFile) break; if (place instanceof GrClosableBlock) return true; place = place.getParent(); } if (place == null || place instanceof PsiFile || place == stopAt) return true; if (place instanceof GrTypeDefinition) { return !(((GrTypeDefinition)place).hasModifierProperty(PsiModifier.STATIC) || ((GrTypeDefinition)place).getContainingClass() == null); } return !((GrMember)place).hasModifierProperty(PsiModifier.STATIC); } else { while (place != null) { place = place.getParent(); if (place instanceof PsiClass && InheritanceUtil.isInheritorOrSelf((PsiClass)place, containingClass, true)) return true; if (place instanceof GrClosableBlock) return true; if (place instanceof PsiMember && ((PsiMember)place).hasModifierProperty(PsiModifier.STATIC)) { return false; } } return true; } } | checkNonQualified |
33,554 | boolean (@NotNull PsiModifierListOwner member, PsiElement place, boolean filterStaticAfterInstanceQualifier, GrExpression qualifier, PsiClass containingClass) { final boolean isStatic = member.hasModifierProperty(PsiModifier.STATIC); if (qualifier instanceof GrReferenceExpression) { if ("class".equals(((GrReferenceExpression)qualifier).getReferenceName())) { //invoke static members of class from A.class.foo() final PsiType type = qualifier.getType(); if (type instanceof PsiClassType) { final PsiClass psiClass = ((PsiClassType)type).resolve(); if (psiClass != null && CommonClassNames.JAVA_LANG_CLASS.equals(psiClass.getQualifiedName())) { final PsiType[] params = ((PsiClassType)type).getParameters(); if (params.length == 1 && params[0] instanceof PsiClassType) { if (place.getManager().areElementsEquivalent(containingClass, ((PsiClassType)params[0]).resolve())) { return member.hasModifierProperty(PsiModifier.STATIC); } } } } } else if (PsiUtil.isThisOrSuperRef(qualifier)) { //static members may be invoked from this.<...> final boolean isInStatic = isInStaticContext(qualifier); if (PsiUtil.isThisReference(qualifier) && isInStatic) { return checkJavaLangClassMember(place, containingClass, member) || member.hasModifierProperty(PsiModifier.STATIC); } return !isStatic || !filterStaticAfterInstanceQualifier; } PsiElement qualifierResolved = ((GrReferenceExpression)qualifier).resolve(); if (qualifierResolved instanceof PsiClass || qualifierResolved instanceof PsiPackage) { //static context if (member instanceof PsiClass) { return true; } if (isStatic) { return true; } //non-physical method, e.g. gdk return containingClass != null && checkJavaLangClassMember(place, containingClass, member); } } //instance context if (member instanceof PsiClass) { return false; } return !isStatic || !filterStaticAfterInstanceQualifier; } | checkQualified |
33,555 | boolean (PsiElement place, PsiClass containingClass, PsiModifierListOwner member) { if (containingClass == null) return false; //members from java.lang.Class can be invoked without ".class" final String qname = containingClass.getQualifiedName(); if (qname != null && qname.startsWith("java.")) { if (CommonClassNames.JAVA_LANG_OBJECT.equals(qname)) { //special check for toString(). Only Class.toString() should be resolved here return !(member instanceof PsiMethod && "toString".equals(((PsiMethod)member).getName())); } else if (CommonClassNames.JAVA_LANG_CLASS.equals(qname)) { return true; } if (containingClass.isInterface()) { PsiClass javaLangClass = JavaPsiFacade.getInstance(place.getProject()).findClass(CommonClassNames.JAVA_LANG_CLASS, place.getResolveScope()); if (javaLangClass != null && javaLangClass.isInheritor(containingClass, true)) { return true; } } } return false; } | checkJavaLangClassMember |
33,556 | PsiClass (PsiMember member) { PsiClass aClass = member.getContainingClass(); if (aClass != null) return aClass; if (member instanceof GrGdkMethod && !member.hasModifierProperty(PsiModifier.STATIC)) { PsiType type = ((GrGdkMethod)member).getReceiverType(); if (type instanceof PsiClassType) { return ((PsiClassType)type).resolve(); } } return null; } | getContainingClass |
33,557 | boolean (@NotNull PsiElement place) { PsiClass targetClass = null; if (place instanceof GrReferenceExpression) { PsiElement qualifier = ((GrQualifiedReference<?>)place).getQualifier(); if (PsiUtil.isThisReference(place) && qualifier instanceof GrQualifiedReference) { targetClass = (PsiClass)((GrQualifiedReference<?>)qualifier).resolve(); } } return isInStaticContext(place, targetClass); } | isInStaticContext |
33,558 | boolean (@NotNull PsiElement place, @Nullable PsiClass targetClass) { if (place instanceof GrReferenceExpression) { GrQualifiedReference reference = (GrQualifiedReference)place; PsiElement qualifier = reference.getQualifier(); if (qualifier != null && !PsiUtil.isThisOrSuperRef(reference)) { if (PsiUtil.isInstanceThisRef(qualifier) || PsiUtil.isSuperReference(qualifier)) { return false; } else if (PsiUtil.isThisReference(qualifier)) { //instance 'this' already is processed. So it static 'this' return true; } return qualifier instanceof GrQualifiedReference && ResolveUtil.resolvesToClass(qualifier); } if (PsiUtil.isSuperReference(reference)) return false; //this reference should be checked as all other refs } PsiElement run = place; while (run != null && run != targetClass) { if (targetClass == null && run instanceof PsiClass) return false; if (run instanceof GrClosableBlock) return false; if (run instanceof PsiModifierListOwner && ((PsiModifierListOwner)run).hasModifierProperty(PsiModifier.STATIC)) return true; run = run.getParent(); } return false; } | isInStaticContext |
33,559 | boolean (@NotNull GrReferenceExpression referenceExpression) { return !referenceExpression.isQualified() && !(referenceExpression.getParent() instanceof GrMethodCall) && isInStaticContext(referenceExpression); } | isPropertyAccessInStaticMethod |
33,560 | PsiType (@NotNull PsiClassType classType) { return classType; } | visitClassType |
33,561 | boolean (@Nullable PsiClass aClass) { return aClass != null && aClass.isInterface() && !(aClass instanceof GrTypeDefinition && ((GrTypeDefinition)aClass).isTrait()); } | isInterface |
33,562 | boolean (@NotNull PsiMethod method) { return method.getModifierList().hasExplicitModifier(ABSTRACT) || isInterface(method.getContainingClass()) && !method.hasModifierProperty(PsiModifier.DEFAULT); } | isMethodAbstract |
33,563 | List<PsiClass> (@NotNull PsiClass trait) { return CachedValuesManager.getCachedValue(trait, () -> { List<PsiClass> result = new ArrayList<>(); InheritanceUtil.processSupers(trait, true, clazz -> { if (isTrait(clazz)) { PsiAnnotation annotation = AnnotationUtil.findAnnotation(clazz, "groovy.transform.SelfType"); if (annotation != null) { result.addAll( GrAnnotationUtil.getClassArrayValue(annotation, "value", false) ); } } return true; }); return CachedValueProvider.Result.create(result, PsiModificationTracker.MODIFICATION_COUNT); }); } | getSelfTypeClasses |
33,564 | String (@NotNull PsiClass aClass) { String qname = aClass.getQualifiedName(); LOG.assertTrue(qname != null, aClass.getClass()); String[] identifiers = qname.split("\\."); StringBuilder buffer = new StringBuilder(); for (String identifier : identifiers) { buffer.append(identifier).append('_'); } buffer.append('_'); return buffer.toString(); } | getTraitFieldPrefix |
33,565 | boolean (@Nullable PsiClass aClass) { return aClass instanceof GrTypeDefinition && ((GrTypeDefinition)aClass).isTrait() || aClass instanceof ClsClassImpl && aClass.isInterface() && AnnotationUtil.isAnnotated(aClass, GROOVY_TRAIT, 0) || getDefaultMethods(aClass).length != 0; } | isTrait |
33,566 | GrMethod[] (@Nullable PsiClass aClass) { if (!(aClass instanceof GrTypeDefinition grTypeDefinition) || !aClass.isInterface()) return GrMethod.EMPTY_ARRAY; return Arrays.stream(grTypeDefinition.getCodeMethods()) .filter(m -> m.getModifierList().hasExplicitModifier(PsiModifier.DEFAULT)) .toArray(GrMethod[]::new); } | getDefaultMethods |
33,567 | Collection<PsiMethod> (@NotNull final ClsClassImpl trait) { return CachedValuesManager.getCachedValue(trait, () -> { final Collection<PsiMethod> result = new ArrayList<>(); doCollectCompiledTraitMethods(trait, result); return CachedValueProvider.Result.create(result, trait); }); } | getCompiledTraitConcreteMethods |
33,568 | void (final ClsClassImpl trait, final Collection<? super PsiMethod> result) { for (PsiMethod method : trait.getMethods()) { if (AnnotationUtil.isAnnotated(method, GROOVY_TRAIT_IMPLEMENTED, 0)) { result.add(method); } } for (PsiMethod staticMethod : GroovyTraitMethodsFileIndex.getStaticTraitMethods(trait)) { result.add(createTraitMethodFromCompiledHelperMethod(staticMethod, trait)); } } | doCollectCompiledTraitMethods |
33,569 | PsiMethod (PsiMethod compiledMethod, ClsClassImpl trait) { final LightMethodBuilder result = new LightMethodBuilder(trait.getManager(), compiledMethod.getName()); result.setOriginInfo("via @Trait"); result.addModifier(PsiModifier.STATIC); for (PsiTypeParameter parameter : compiledMethod.getTypeParameters()) { result.addTypeParameter(parameter); } final PsiTypeVisitor<PsiType> corrector = createCorrector(compiledMethod, trait); final PsiParameter[] methodParameters = compiledMethod.getParameterList().getParameters(); for (int i = 1; i < methodParameters.length; i++) { final PsiParameter originalParameter = methodParameters[i]; final PsiType correctedType = originalParameter.getType().accept(corrector); result.addParameter(withType(originalParameter, correctedType)); } for (PsiClassType type : compiledMethod.getThrowsList().getReferencedTypes()) { final PsiType correctedType = type.accept(corrector); result.addException(correctedType instanceof PsiClassType ? (PsiClassType)correctedType : type); } final PsiType originalType = compiledMethod.getReturnType(); result.setMethodReturnType(originalType == null ? null : originalType.accept(corrector)); final PsiClass traitSource = trait.getSourceMirrorClass(); final PsiMethod sourceMethod = traitSource == null ? null : traitSource.findMethodBySignature(result, false); result.setNavigationElement(sourceMethod != null ? sourceMethod : compiledMethod); return result; } | createTraitMethodFromCompiledHelperMethod |
33,570 | PsiTypeMapper (final PsiMethod compiledMethod, final PsiClass trait) { final PsiTypeParameter[] traitTypeParameters = trait.getTypeParameters(); if (traitTypeParameters.length == 0) return ID_MAPPER; final Map<String, PsiTypeParameter> substitutionMap = new HashMap<>(); for (PsiTypeParameter parameter : traitTypeParameters) { substitutionMap.put(parameter.getName(), parameter); } final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(trait.getProject()).getElementFactory(); return new PsiTypeMapper() { @Override public PsiType visitClassType(@NotNull PsiClassType originalType) { final PsiClass resolved = originalType.resolve(); // if resolved to method parameter -> return as is if (resolved instanceof PsiTypeParameter && compiledMethod.equals(((PsiTypeParameter)resolved).getOwner())) return originalType; final PsiType[] typeParameters = originalType.getParameters(); final PsiTypeParameter byName = substitutionMap.get(originalType.getCanonicalText()); if (byName != null) { assert typeParameters.length == 0; return elementFactory.createType(byName); } if (resolved == null) return originalType; if (typeParameters.length == 0) return originalType; // do not go deeper final Ref<Boolean> hasChanges = Ref.create(false); final PsiTypeVisitor<PsiType> $this = this; final PsiType[] substitutes = ContainerUtil.map2Array(typeParameters, PsiType.class, type -> { final PsiType mapped = type.accept($this); hasChanges.set(mapped != type); return mapped; }); return hasChanges.get() ? elementFactory.createType(resolved, substitutes) : originalType; } }; } | createCorrector |
33,571 | PsiType (@NotNull PsiClassType originalType) { final PsiClass resolved = originalType.resolve(); // if resolved to method parameter -> return as is if (resolved instanceof PsiTypeParameter && compiledMethod.equals(((PsiTypeParameter)resolved).getOwner())) return originalType; final PsiType[] typeParameters = originalType.getParameters(); final PsiTypeParameter byName = substitutionMap.get(originalType.getCanonicalText()); if (byName != null) { assert typeParameters.length == 0; return elementFactory.createType(byName); } if (resolved == null) return originalType; if (typeParameters.length == 0) return originalType; // do not go deeper final Ref<Boolean> hasChanges = Ref.create(false); final PsiTypeVisitor<PsiType> $this = this; final PsiType[] substitutes = ContainerUtil.map2Array(typeParameters, PsiType.class, type -> { final PsiType mapped = type.accept($this); hasChanges.set(mapped != type); return mapped; }); return hasChanges.get() ? elementFactory.createType(resolved, substitutes) : originalType; } | visitClassType |
33,572 | Collection<GrField> (@NotNull final ClsClassImpl trait) { return CachedValuesManager.getCachedValue(trait, () -> { final Collection<GrField> result = new ArrayList<>(); doCollectCompiledTraitFields(trait, result); return CachedValueProvider.Result.create(result, trait); }); } | getCompiledTraitFields |
33,573 | void (ClsClassImpl trait, Collection<? super GrField> result) { VirtualFile traitFile = trait.getContainingFile().getVirtualFile(); if (traitFile == null) return; VirtualFile helperFile = traitFile.getParent().findChild(trait.getName() + GroovyTraitFieldsFileIndex.HELPER_SUFFIX); if (helperFile == null) return; Collection<TraitFieldDescriptor> values = GROOVY_TRAIT_FIELDS_GIST.getFileData(trait.getProject(), helperFile); if (values != null) { values.forEach(descriptor -> result.add(createTraitField(descriptor, trait))); } } | doCollectCompiledTraitFields |
33,574 | GrLightField (TraitFieldDescriptor descriptor, PsiClass trait) { GrLightField field = new GrLightField(trait, descriptor.name, descriptor.typeString); GrLightModifierList modifierList = field.getModifierList(); if ((descriptor.flags & TraitFieldDescriptor.STATIC) != 0) modifierList.addModifier(STATIC_MASK); modifierList.addModifier((descriptor.flags & TraitFieldDescriptor.PUBLIC) != 0 ? PUBLIC_MASK : PRIVATE_MASK); GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(trait.getProject()); for (String annotationText : descriptor.annotations) { GrAnnotation annotation = factory.createAnnotationFromText(annotationText, modifierList); modifierList.addAnnotation(annotation); } return field; } | createTraitField |
33,575 | boolean (final PsiElement place, final PsiScopeProcessor processor, @NotNull final ResolveState state, @NotNull final PsiClass categoryClass) { for (final PsiScopeProcessor each : MultiProcessor.allProcessors(processor)) { final PsiScopeProcessor delegate = new DelegatingScopeProcessor(each) { @Override public boolean execute(@NotNull PsiElement element, @NotNull ResolveState delegateState) { if (element instanceof PsiMethod method && isCategoryMethod((PsiMethod)element, null, null, null)) { return each.execute(GrGdkMethodImpl.createGdkMethod(method, false, generateOriginInfo(method)), delegateState); } return true; } }; if (!categoryClass.processDeclarations(delegate, state, null, place)) return false; } return true; } | processCategoryMethods |
33,576 | boolean (@NotNull PsiElement element, @NotNull ResolveState delegateState) { if (element instanceof PsiMethod method && isCategoryMethod((PsiMethod)element, null, null, null)) { return each.execute(GrGdkMethodImpl.createGdkMethod(method, false, generateOriginInfo(method)), delegateState); } return true; } | execute |
33,577 | boolean (PsiElement resolveContext) { if (resolveContext instanceof GrExpression) { final PsiElement parent = resolveContext.getParent(); if (parent instanceof GrReferenceExpression && ((GrReferenceExpression)parent).getQualifier() == resolveContext) { final PsiElement pparent = parent.getParent(); if (pparent instanceof GrMethodCall) { final PsiMethod method = ((GrMethodCall)pparent).resolveMethod(); if (method instanceof GrGdkMethod && isWithName(method.getName())) { return true; } } } } return false; } | isInWithContext |
33,578 | boolean (String name) { return WITH.equals(name) || IDENTITY.equals(name) || TAP.equals(name); } | isWithName |
33,579 | String (PsiMethod method) { PsiClass cc = method.getContainingClass(); if (cc == null) return null; //'\u2191' return "via " + cc.getName(); } | generateOriginInfo |
33,580 | boolean (GrStatementOwner run, final PsiScopeProcessor processor, ResolveState state, PsiElement lastParent, PsiElement place) { if (!ResolveUtilKt.shouldProcessMethods(processor)) return true; GrStatement[] statements = run.getStatements(); for (GrStatement statement : statements) { if (statement == lastParent) break; final MixinInfo result = getMixinTypes(statement); if (result != null) { final PsiClassType subjectType = result.subjectType; final GrReferenceExpression qualifier = result.ref; final PsiClass mixin = result.mixin; for (PsiScopeProcessor each : MultiProcessor.allProcessors(processor)) { if (!mixin.processDeclarations(new MixinMemberContributor.MixinProcessor(each, subjectType, qualifier), state, null, place)) { return false; } } } else { Trinity<PsiClassType, GrReferenceExpression, List<GrMethod>> closureResult = getClosureMixins(statement); if (closureResult != null) { final PsiClassType subjectType = closureResult.first; final GrReferenceExpression qualifier = closureResult.second; final List<GrMethod> methods = closureResult.third; final DelegatingScopeProcessor delegate = new MixinMemberContributor.MixinProcessor(processor, subjectType, qualifier); for (GrMethod method : methods) { ResolveUtil.processElement(delegate, method, state); } } } } return true; } | processMixinToMetaclass |
33,581 | GrMethod (@NotNull CallSignature<?> signature, @NotNull String name, @NotNull GrAssignmentExpression statement, @NotNull PsiClass closure) { final GrLightMethodBuilder builder = new GrLightMethodBuilder(statement.getManager(), name); int i = 0; for (CallParameter parameter : signature.getParameters()) { final String parameterName = ObjectUtils.notNull(parameter.getParameterName(), "p" + i); final PsiType type = ObjectUtils.notNull(parameter.getType(), () -> TypesUtil.getJavaLangObject(statement)); builder.addParameter(parameterName, type, parameter.isOptional()); i++; } builder.setNavigationElement(statement.getLValue()); builder.setReturnType(signature.getReturnType()); builder.setContainingClass(closure); return builder; } | createMethod |
33,582 | MixinInfo (final GrStatement statement) { if (!(statement instanceof GrMethodCall)) return null; return CachedValuesManager.getCachedValue(statement, () -> { GrMethodCall call = (GrMethodCall)statement; Pair<PsiClassType, GrReferenceExpression> original = getTypeToMixIn(call); if (original == null) return CachedValueProvider.Result.create(null, PsiModificationTracker.MODIFICATION_COUNT); PsiClass mix = getTypeToMix(call); if (mix == null) return CachedValueProvider.Result.create(null, PsiModificationTracker.MODIFICATION_COUNT); return CachedValueProvider.Result .create(new MixinInfo(original.first, original.second, mix), PsiModificationTracker.MODIFICATION_COUNT); }); } | getMixinTypes |
33,583 | PsiClass (GrMethodCall call) { if (!isSingleExpressionArg(call)) return null; GrExpression mixinRef = call.getExpressionArguments()[0]; if (isClassRef(mixinRef)) { mixinRef = ((GrReferenceExpression)mixinRef).getQualifier(); } if (mixinRef instanceof GrReferenceExpression) { PsiElement resolved = ((GrReferenceExpression)mixinRef).resolve(); if (resolved instanceof PsiClass) { return (PsiClass)resolved; } } return null; } | getTypeToMix |
33,584 | boolean (@NotNull GrMethodCall call) { return call.getExpressionArguments().length == 1 && !PsiImplUtil.hasNamedArguments(call.getArgumentList()) && !call.hasClosureArguments(); } | isSingleExpressionArg |
33,585 | boolean (@NotNull PsiMethod method) { if (method instanceof GrGdkMethod) method = ((GrGdkMethod)method).getStaticMethod(); PsiClass containingClass = method.getContainingClass(); String name = method.getName(); return "mixin".equals(name) && containingClass != null && GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(containingClass.getQualifiedName()); } | isMixinMethod |
33,586 | boolean (@NotNull PsiMethod method) { if (method instanceof GrGdkMethod) method = ((GrGdkMethod)method).getStaticMethod(); PsiClass containingClass = method.getContainingClass(); String name = method.getName(); return "getMetaClass".equals(name) && containingClass != null && (method.getParameterList().isEmpty() ^ GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(containingClass.getQualifiedName())); } | isMetaClassMethod |
33,587 | boolean (PsiType qualifierType) { return qualifierType != null && qualifierType.equalsToText(GroovyCommonClassNames.GROOVY_LANG_META_CLASS); } | isMetaClass |
33,588 | boolean (GrExpression mixinRef) { return mixinRef instanceof GrReferenceExpression && "class".equals(((GrReferenceExpression)mixinRef).getReferenceName()); } | isClassRef |
33,589 | boolean (@NotNull PsiMethod method, @Nullable PsiType qualifierType, @Nullable PsiElement place, @Nullable PsiSubstitutor substitutor) { if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false; final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length == 0) return false; if (qualifierType == null) return true; PsiType selfType = parameters[0].getType(); if (selfType instanceof PsiPrimitiveType) return false; if (substitutor != null) { selfType = substitutor.substitute(selfType); } if (PsiTypesUtil.classNameEquals(selfType, CommonClassNames.JAVA_LANG_CLASS) && place instanceof GrReferenceExpression && ((GrReferenceExpression)place).resolve() instanceof PsiClass) { // ClassType.categoryMethod() where categoryMethod(Class<> cl, ...) return TypesUtil.isAssignableByMethodCallConversion(selfType, TypesUtil.createJavaLangClassType(qualifierType, method), method); } return TypesUtil.isAssignableByMethodCallConversion(selfType, qualifierType, method); } | isCategoryMethod |
33,590 | PsiClassType (@NotNull final PsiClass categoryAnnotationOwner) { return CachedValuesManager.getCachedValue(categoryAnnotationOwner, new CachedValueProvider<>() { @Override public Result<PsiClassType> compute() { return Result.create(inferCategoryType(categoryAnnotationOwner), PsiModificationTracker.MODIFICATION_COUNT); } @Nullable private static PsiClassType inferCategoryType(final PsiClass aClass) { return RecursionManager.doPreventingRecursion(aClass, true, (NullableComputable<PsiClassType>)() -> { final PsiModifierList modifierList = aClass.getModifierList(); if (modifierList == null) return null; final PsiAnnotation annotation = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_CATEGORY); if (annotation == null) return null; PsiAnnotationMemberValue value = annotation.findAttributeValue("value"); if (!(value instanceof GrReferenceExpression)) return null; if ("class".equals(((GrReferenceExpression)value).getReferenceName())) value = ((GrReferenceExpression)value).getQualifier(); if (!(value instanceof GrReferenceExpression)) return null; final PsiElement resolved = ((GrReferenceExpression)value).resolve(); if (!(resolved instanceof PsiClass)) return null; String className = ((PsiClass)resolved).getQualifiedName(); if (className == null) className = ((PsiClass)resolved).getName(); if (className == null) return null; return JavaPsiFacade.getElementFactory(aClass.getProject()).createTypeByFQClassName(className, resolved.getResolveScope()); }); } }); } | getCategoryType |
33,591 | Result<PsiClassType> () { return Result.create(inferCategoryType(categoryAnnotationOwner), PsiModificationTracker.MODIFICATION_COUNT); } | compute |
33,592 | PsiClassType (final PsiClass aClass) { return RecursionManager.doPreventingRecursion(aClass, true, (NullableComputable<PsiClassType>)() -> { final PsiModifierList modifierList = aClass.getModifierList(); if (modifierList == null) return null; final PsiAnnotation annotation = modifierList.findAnnotation(GroovyCommonClassNames.GROOVY_LANG_CATEGORY); if (annotation == null) return null; PsiAnnotationMemberValue value = annotation.findAttributeValue("value"); if (!(value instanceof GrReferenceExpression)) return null; if ("class".equals(((GrReferenceExpression)value).getReferenceName())) value = ((GrReferenceExpression)value).getQualifier(); if (!(value instanceof GrReferenceExpression)) return null; final PsiElement resolved = ((GrReferenceExpression)value).resolve(); if (!(resolved instanceof PsiClass)) return null; String className = ((PsiClass)resolved).getQualifiedName(); if (className == null) className = ((PsiClass)resolved).getName(); if (className == null) return null; return JavaPsiFacade.getElementFactory(aClass.getProject()).createTypeByFQClassName(className, resolved.getResolveScope()); }); } | inferCategoryType |
33,593 | boolean (@Nullable PsiElement element) { if (element instanceof PsiMethod && isWithName(((PsiMethod)element).getName())) { if (element instanceof GrGdkMethod) { element = ((GrGdkMethod)element).getStaticMethod(); } final PsiClass containingClass = ((PsiMethod)element).getContainingClass(); if (containingClass != null) { if (GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(containingClass.getQualifiedName())) { return true; } } } return false; } | isWithOrIdentity |
33,594 | PsiMethod (@NotNull PsiMethod prototype) { GrLightMethodBuilder syntheticMacro = new GrLightMethodBuilder(prototype.getManager(), prototype.getName()); syntheticMacro.setModifiers(new String[]{PsiModifier.STATIC}); PsiParameterList list = prototype.getParameterList(); for (int i = 1; i < list.getParametersCount(); ++i) { PsiParameter actualParameter = list.getParameter(i); String generatedParameterType; String name; if (actualParameter == null) { generatedParameterType = CommonClassNames.JAVA_LANG_OBJECT; name = "expression"; } else { PsiType type = actualParameter.getType(); if (!type.equals(PsiTypes.nullType())) { generatedParameterType = AST_TO_EXPR_MAPPER.getOrDefault(type.getCanonicalText(), CommonClassNames.JAVA_LANG_OBJECT); } else { generatedParameterType = CommonClassNames.JAVA_LANG_OBJECT; } name = actualParameter.getName(); } syntheticMacro.addParameter( new GrLightParameter(name, PsiType.getTypeByName(generatedParameterType, prototype.getProject(), GlobalSearchScope.allScope(prototype.getProject())), prototype)); } syntheticMacro.setNavigationElement(prototype); syntheticMacro.setOriginInfo(MACRO_ORIGIN_INFO); return syntheticMacro; } | createMacroMethod |
33,595 | boolean (@Nullable PsiMethod method) { return method instanceof OriginInfoAwareElement && MACRO_ORIGIN_INFO.equals(((OriginInfoAwareElement)method).getOriginInfo()); } | isMacro |
33,596 | boolean (PsiElement element) { final ErrorElementVisitor visitor = new ErrorElementVisitor(); element.accept(visitor); return visitor.containsErrorElement(); } | containsError |
33,597 | void (@NotNull PsiErrorElement element) { containsErrorElement = true; } | visitErrorElement |
33,598 | boolean () { return containsErrorElement; } | containsErrorElement |
33,599 | PsiMethod[] (PsiField field) { return getAllSetters(field.getContainingClass(), field.getName(), field.hasModifierProperty(PsiModifier.STATIC), false); } | getAllSettersByField |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.