Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
31,800 | StringBuilder () { return builder; } | getBuilder |
31,801 | ExpressionContext () { return context; } | getContext |
31,802 | void (@NotNull GrExpression expression) { expression.accept(expressionGenerator); } | visitExpression |
31,803 | void (@NotNull GrAnnotationArrayInitializer arrayInitializer) { GrAnnotationMemberValue[] initializers = arrayInitializer.getInitializers(); builder.append('{'); for (GrAnnotationMemberValue initializer : initializers) { initializer.accept(this); builder.append(", "); } if (initializers.length > 0) { builder.delete(builder.length()-2, builder.length()); //builder.removeFromTheEnd(2); } builder.append('}'); } | visitAnnotationArrayInitializer |
31,804 | void (@NotNull GrAnnotation annotation) { String qualifiedName = annotation.getQualifiedName(); if (qualifiedName != null && ContainerUtil.exists(SKIPPED, qualifiedName::contains)) return; builder.append('@'); GrCodeReferenceElement classReference = annotation.getClassReference(); GenerationUtil.writeCodeReferenceElement(builder, classReference); GrAnnotationArgumentList parameterList = annotation.getParameterList(); GrAnnotationNameValuePair[] attributes = parameterList.getAttributes(); if (attributes.length == 0) return; builder.append('('); for (GrAnnotationNameValuePair attribute : attributes) { String name = attribute.getName(); if (name != null) { builder.append(name); builder.append(" = "); } GrAnnotationMemberValue value = attribute.getValue(); if (value != null) { value.accept(this); } builder.append(", "); } builder.delete(builder.length()-2, builder.length()); //builder.removeFromTheEnd(2); builder.append(')'); } | visitAnnotation |
31,805 | void (StringBuilder text, GrEnumConstant enumConstant) { text.append(enumConstant.getName()); PsiMethod constructor = enumConstant.resolveMethod(); if (constructor != null) { text.append('('); writeStubConstructorInvocation(text, constructor, PsiSubstitutor.EMPTY, enumConstant); text.append(')'); } GrEnumConstantInitializer initializer = enumConstant.getInitializingClass(); if (initializer != null) { text.append("{\n"); for (PsiMethod method : initializer.getMethods()) { writeMethod(text, method); } text.append('}'); } } | writeEnumConstant |
31,806 | void (StringBuilder text, PsiMethod constructor, PsiSubstitutor substitutor, PsiElement invocation) { final PsiParameter[] superParams = constructor.getParameterList().getParameters(); for (int j = 0; j < superParams.length; j++) { if (j > 0) text.append(", "); text.append('('); final PsiType type = superParams[j].getType(); TypeWriter.writeType(text, substitutor.substitute(type), invocation, classNameProvider); text.append(')').append(GroovyToJavaGenerator.getDefaultValueText(type.getCanonicalText())); } } | writeStubConstructorInvocation |
31,807 | void (final StringBuilder text, PsiMethod constructor, boolean isEnum) { LOG.assertTrue(constructor.isConstructor()); if (!isEnum) { text.append("public "); //writeModifiers(text, constructor.getModifierList(), JAVA_MODIFIERS); } // ************* name **********/ //append constructor name text.append(constructor.getName()); // ************* parameters **********/ GenerationUtil.writeParameterList(text, constructor.getParameterList().getParameters(), classNameProvider, null); final Set<String> throwsTypes = collectThrowsTypes(constructor, new HashSet<>()); if (!throwsTypes.isEmpty()) { text.append("throws ").append(StringUtil.join(throwsTypes, ", ")).append(' '); } // ************* body **********/ text.append("{\n"); if (constructor instanceof GrReflectedMethod) { constructor = ((GrReflectedMethod)constructor).getBaseMethod(); } if (constructor instanceof GrMethod) { final GrConstructorInvocation invocation = PsiImplUtil.getChainingConstructorInvocation((GrMethod)constructor); if (invocation != null) { final GroovyResolveResult resolveResult = resolveChainingConstructor((GrMethod)constructor); if (resolveResult != null) { text.append(invocation.isSuperCall() ? "super(" : "this("); writeStubConstructorInvocation(text, (PsiMethod)resolveResult.getElement(), resolveResult.getSubstitutor(), invocation); text.append(");"); } } else if (constructor instanceof LightElement) { writeStubConstructorInvocation(constructor, text); } } text.append("\n}\n"); } | writeConstructor |
31,808 | void (PsiMethod constructor, StringBuilder text) { final PsiClass containingClass = constructor.getContainingClass(); if (containingClass == null) return; final PsiClass superClass = containingClass.getSuperClass(); if (superClass == null) return; final PsiMethod[] constructors = superClass.getConstructors(); if (constructors.length == 0) return; for (PsiMethod method : constructors) { if (method.getParameterList().isEmpty() && PsiUtil.isAccessible(method, containingClass, containingClass)) { return; //default constructor exists } } for (PsiMethod method : constructors) { if (PsiUtil.isAccessible(method, containingClass, containingClass)) { text.append("super("); writeStubConstructorInvocation(text, method, TypeConversionUtil.getSuperClassSubstitutor(superClass, containingClass, PsiSubstitutor.EMPTY), constructor); text.append(");"); return; } } } | writeStubConstructorInvocation |
31,809 | Set<String> (PsiMethod constructor, Set<PsiMethod> visited) { LOG.assertTrue(constructor.isConstructor()); final GroovyResolveResult resolveResult = constructor instanceof GrMethod ? resolveChainingConstructor((GrMethod)constructor) : null; if (resolveResult == null) { return Collections.emptySet(); } final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); final PsiMethod chainedConstructor = (PsiMethod)resolveResult.getElement(); assert chainedConstructor != null; if (!visited.add(chainedConstructor)) { return Collections.emptySet(); } final Set<String> result = new HashSet<>(); for (PsiClassType type : chainedConstructor.getThrowsList().getReferencedTypes()) { StringBuilder builder = new StringBuilder(); TypeWriter.writeType(builder, substitutor.substitute(type), constructor, classNameProvider); result.add(builder.toString()); } if (chainedConstructor instanceof GrMethod) { LOG.assertTrue(chainedConstructor.isConstructor()); result.addAll(collectThrowsTypes(chainedConstructor, visited)); } return result; } | collectThrowsTypes |
31,810 | void (StringBuilder text, PsiMethod method) { if (method == null) return; String name = method.getName(); if (!PsiNameHelper.getInstance(method.getProject()).isIdentifier(name)) { return; //does not have a java image } boolean isAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT); PsiModifierList modifierList = method.getModifierList(); ModifierListGenerator.writeModifiers(text, modifierList, STUB_MODIFIERS, false); if (method.hasTypeParameters()) { GenerationUtil.writeTypeParameters(text, method, classNameProvider); text.append(' '); } //append return type PsiType retType = method.getReturnType(); if (retType == null) { retType = TypesUtil.getJavaLangObject(method); } if (!method.hasModifierProperty(PsiModifier.STATIC)) { final List<MethodSignatureBackedByPsiMethod> superSignatures = method.findSuperMethodSignaturesIncludingStatic(true); for (MethodSignatureBackedByPsiMethod superSignature : superSignatures) { final PsiType superType = superSignature.getSubstitutor().substitute(superSignature.getMethod().getReturnType()); if (superType != null && !superType.isAssignableFrom(retType) && !(PsiUtil.resolveClassInType(superType) instanceof PsiTypeParameter)) { retType = superType; } } } TypeWriter.writeType(text, retType, method, classNameProvider); text.append(' '); text.append(name); GenerationUtil.writeParameterList(text, method.getParameterList().getParameters(), classNameProvider, null); writeThrowsList(text, method); if (!isAbstract && !method.hasModifierProperty(PsiModifier.NATIVE)) { // ************* body **********/ text.append("{\nreturn "); text.append(GroovyToJavaGenerator.getDefaultValueText(retType.getCanonicalText())); text.append(";\n}"); } else { text.append(';'); } text.append('\n'); } | writeMethod |
31,811 | void (StringBuilder text, PsiMethod method) { final PsiReferenceList throwsList = method.getThrowsList(); final PsiClassType[] exceptions = throwsList.getReferencedTypes(); GenerationUtil.writeThrowsList(text, throwsList, exceptions, classNameProvider); } | writeThrowsList |
31,812 | GroovyResolveResult (GrMethod constructor) { LOG.assertTrue(constructor.isConstructor()); final GrConstructorInvocation constructorInvocation = PsiImplUtil.getChainingConstructorInvocation(constructor); if (constructorInvocation == null) { return null; } GroovyResolveResult resolveResult = constructorInvocation.advancedResolve(); if (resolveResult.getElement() != null) { return resolveResult; } final GroovyResolveResult[] results = constructorInvocation.multiResolve(false); if (results.length > 0) { int i = 0; while (results.length > i + 1) { final PsiMethod candidate = (PsiMethod)results[i].getElement(); final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(constructor.getProject()).getResolveHelper(); if (candidate != null && candidate != constructor && resolveHelper.isAccessible(candidate, constructorInvocation, null)) { break; } i++; } return results[i]; } return null; } | resolveChainingConstructor |
31,813 | Collection<PsiMethod> (PsiClass typeDefinition) { List<PsiMethod> methods = new ArrayList<>(); for (PsiMethod method : typeDefinition.getMethods()) { if (method instanceof DelegatedMethod) { PsiMethod prototype = ((DelegatedMethod)method).getPrototype(); PsiClass aClass = prototype.getContainingClass(); if (prototype.hasModifierProperty(PsiModifier.FINAL) && aClass != null && typeDefinition.isInheritor(aClass, true)) { continue; //skip final super methods } } methods.add(method); } boolean isClass = !typeDefinition.isInterface() && !typeDefinition.isAnnotationType() && !typeDefinition.isEnum() && !(typeDefinition instanceof GroovyScriptClass); if (isClass) { final Collection<MethodSignature> toOverride = OverrideImplementExploreUtil.getMethodSignaturesToOverride(typeDefinition); for (MethodSignature signature : toOverride) { if (!(signature instanceof MethodSignatureBackedByPsiMethod)) continue; final PsiMethod method = ((MethodSignatureBackedByPsiMethod)signature).getMethod(); final PsiClass baseClass = method.getContainingClass(); if (baseClass == null) continue; final String qname = baseClass.getQualifiedName(); if (GroovyCommonClassNames.GROOVY_OBJECT.equals(qname) || GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(qname) || method.hasModifierProperty(PsiModifier.ABSTRACT) && typeDefinition.isInheritor(baseClass, true)) { if (method.isConstructor()) continue; methods.add(mirrorMethod(typeDefinition, method, baseClass, signature.getSubstitutor())); } } final Collection<MethodSignature> toImplement = OverrideImplementExploreUtil.getMethodSignaturesToImplement(typeDefinition); for (MethodSignature signature : toImplement) { if (!(signature instanceof MethodSignatureBackedByPsiMethod)) continue; final PsiMethod resolved = ((MethodSignatureBackedByPsiMethod)signature).getMethod(); final PsiClass baseClass = resolved.getContainingClass(); if (baseClass == null) continue; if (!GroovyCommonClassNames.GROOVY_OBJECT.equals(baseClass.getQualifiedName())) continue; methods.add(mirrorMethod(typeDefinition, resolved, baseClass, signature.getSubstitutor())); } } return methods; } | collectMethods |
31,814 | boolean () { return false; } | generateAnnotations |
31,815 | void (StringBuilder text, PsiClass psiClass) { } | writePostponed |
31,816 | LightMethodBuilder (PsiClass typeDefinition, PsiMethod method, PsiClass baseClass, PsiSubstitutor substitutor) { final LightMethodBuilder builder = new LightMethodBuilder(method.getManager(), method.getName()); substitutor = substitutor.putAll(TypeConversionUtil.getSuperClassSubstitutor(baseClass, typeDefinition, PsiSubstitutor.EMPTY)); for (PsiParameter parameter : method.getParameterList().getParameters()) { builder.addParameter(parameter.getName(), substitutor.substitute(parameter.getType())); } builder.setMethodReturnType(substitutor.substitute(method.getReturnType())); for (String modifier : STUB_MODIFIERS) { if (method.hasModifierProperty(modifier)) { builder.addModifier(modifier); } } return builder; } | mirrorMethod |
31,817 | void (StringBuilder text, GrVariableDeclaration variableDeclaration) { GrTypeElement typeElement = variableDeclaration.getTypeElementGroovy(); final GrModifierList modifierList = variableDeclaration.getModifierList(); final PsiNameHelper nameHelper = PsiNameHelper.getInstance(variableDeclaration.getProject()); for (final GrVariable variable : variableDeclaration.getVariables()) { String name = variable.getName(); if (!nameHelper.isIdentifier(name)) { continue; //does not have a java image } ModifierListGenerator.writeModifiers(text, modifierList, STUB_FIELD_MODIFIERS, false); //type PsiType declaredType = typeElement == null ? PsiType.getJavaLangObject(variable.getManager(), variable.getResolveScope()) : typeElement.getType(); TypeWriter.writeType(text, declaredType, variableDeclaration, classNameProvider); text.append(' ').append(name).append(" = ").append(getVariableInitializer(variable, declaredType)); text.append(";\n"); } } | writeVariableDeclarations |
31,818 | String (GrVariable variable, PsiType declaredType) { if (declaredType instanceof PsiPrimitiveType) { Object eval = GroovyConstantExpressionEvaluator.evaluate(variable.getInitializerGroovy()); if (eval instanceof Float || PsiTypes.floatType().equals(TypesUtil.unboxPrimitiveTypeWrapper(variable.getType())) && eval instanceof Number) { return eval.toString() + "f"; } else if (eval instanceof Character) { StringBuilder buffer = new StringBuilder(); buffer.append('\''); StringUtil.escapeStringCharacters(1, Character.toString(((Character)eval).charValue()), buffer); buffer.append('\''); return buffer.toString(); } if (eval instanceof Number || eval instanceof Boolean) { return eval.toString(); } } return GroovyToJavaGenerator.getDefaultValueText(declaredType.getCanonicalText()); } | getVariableInitializer |
31,819 | void (StringBuilder text, PsiClass typeDefinition) { final Collection<PsiClassType> implementsTypes = new LinkedHashSet<>(); Collections.addAll(implementsTypes, typeDefinition.getImplementsListTypes()); if (implementsTypes.isEmpty()) return; text.append(typeDefinition.isInterface() ? "extends " : "implements "); for (PsiClassType implementsType : implementsTypes) { TypeWriter.writeType(text, implementsType, typeDefinition, classNameProvider); text.append(", "); } text.delete(text.length() - 2, text.length()); text.append(' '); } | writeImplementsList |
31,820 | void (StringBuilder text, PsiClass typeDefinition) { final PsiClassType[] extendsClassesTypes = typeDefinition.getExtendsListTypes(); if (extendsClassesTypes.length > 0) { text.append("extends "); TypeWriter.writeType(text, extendsClassesTypes[0], typeDefinition, classNameProvider); text.append(' '); } } | writeExtendsList |
31,821 | boolean (@NotNull ExpressionGenerator generator, @NotNull GrGdkMethod method, @Nullable GrExpression caller, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closures, @NotNull PsiSubstitutor substitutor, @NotNull GroovyPsiElement context) { final PsiMethod staticMethod = method.getStaticMethod(); for (CustomMethodInvocator invocator : EP_NAME.getExtensions()) { if (invocator.invoke(generator, staticMethod, caller, exprs, namedArgs, closures, substitutor, context)) { return true; } } return false; } | invokeMethodOn |
31,822 | boolean (@NotNull ExpressionGenerator generator, @NotNull PsiMethod method, @Nullable GrExpression caller, GrExpression @NotNull [] exprs, GrNamedArgument @NotNull [] namedArgs, GrClosableBlock @NotNull [] closures, @NotNull PsiSubstitutor substitutor, @NotNull GroovyPsiElement context) { if (!method.getName().equals("putAt") && !method.getName().equals("getAt")) return false; final PsiClass clazz = method.getContainingClass(); if (clazz == null) return false; final String qname = clazz.getQualifiedName(); if (!GroovyCommonClassNames.DEFAULT_GROOVY_METHODS.equals(qname)) return false; if (caller == null) return false; final PsiType type = caller.getType(); if (method.getName().equals("getAt")) { if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) { GenerationUtil.invokeMethodByName(caller, "get", exprs, namedArgs, closures, generator, context); return true; } else if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_LIST)) { GenerationUtil.invokeMethodByName(caller, "get", exprs, namedArgs, closures, generator, context); return true; } } else if (method.getName().equals("putAt")) { if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) { GenerationUtil.invokeMethodByName(caller, "put", exprs, namedArgs, closures, generator, context); return true; } else if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_LIST)) { GenerationUtil.invokeMethodByName(caller, "set", exprs, namedArgs, closures, generator, context); return true; } } return false; } | invoke |
31,823 | void (@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { int offset = editor.getCaretModel().getOffset(); editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE); PsiElement element = file.findElementAt(offset); while (true) { if (element == null || element instanceof PsiFile) { String message = RefactoringBundle .getCannotRefactorMessage(RefactoringBundle.message("the.caret.should.be.positioned.inside.a.class.to.pull.members.from")); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HelpID.MEMBERS_PULL_UP); return; } if (!CommonRefactoringUtil.checkReadOnlyStatus(project, element)) return; if (element instanceof GrTypeDefinition || element instanceof GrField || element instanceof GrMethod) { invoke(project, new PsiElement[]{element}, dataContext); return; } element = element.getParent(); } } | invoke |
31,824 | void (@NotNull final Project project, PsiElement @NotNull [] elements, DataContext dataContext) { if (elements.length != 1) return; myProject = project; PsiElement element = elements[0]; if (element instanceof GrTypeDefinition) { GrTypeDefinition aClass = (GrTypeDefinition)element; invokeImpl(project, dataContext, aClass, null); } else if (element instanceof GrMethod || element instanceof GrField) { GrTypeDefinition aClass = (GrTypeDefinition)((GrMember)element).getContainingClass(); invokeImpl(project, dataContext, aClass, element); } } | invoke |
31,825 | void (Project project, DataContext dataContext, GrTypeDefinition aClass, PsiElement aMember) { final Editor editor = dataContext != null ? CommonDataKeys.EDITOR.getData(dataContext) : null; if (aClass == null) { String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("is.not.supported.in.the.current.context", getRefactoringName())); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HelpID.MEMBERS_PULL_UP); return; } ArrayList<PsiClass> bases = RefactoringHierarchyUtil.createBasesList(aClass, false, true); if (bases.isEmpty()) { final GrTypeDefinition containingClass = (GrTypeDefinition)aClass.getContainingClass(); if (containingClass != null) { invokeImpl(project, dataContext, containingClass, aClass); return; } String message = RefactoringBundle.getCannotRefactorMessage( RefactoringBundle.message("class.does.not.have.base.classes.interfaces.in.current.project", aClass.getQualifiedName())); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HelpID.MEMBERS_PULL_UP); return; } mySubclass = aClass; GrMemberInfoStorage memberInfoStorage = new GrMemberInfoStorage((GrTypeDefinition)mySubclass, new MemberInfoBase.Filter<>() { @Override public boolean includeMember(GrMember element) { return true; } }); List<GrMemberInfo> members = memberInfoStorage.getClassMemberInfos(mySubclass); PsiManager manager = mySubclass.getManager(); for (GrMemberInfo member : members) { if (manager.areElementsEquivalent(member.getMember(), aMember)) { member.setChecked(true); break; } } final GrPullUpDialog dialog = new GrPullUpDialog(project, aClass, bases, memberInfoStorage, this); dialog.show(); } | invokeImpl |
31,826 | boolean (GrMember element) { return true; } | includeMember |
31,827 | boolean (final GrPullUpDialog dialog) { /* todo */ List<GrMemberInfo> _infos = dialog.getSelectedMemberInfos(); final GrMemberInfo[] infos = _infos.toArray(new GrMemberInfo[0]); final PsiClass superClass = dialog.getSuperClass(); if (!checkWritable(superClass, infos)) return false; final MultiMap<PsiElement, String> conflicts = new MultiMap<>(); if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(() -> ApplicationManager.getApplication().runReadAction(() -> { final PsiDirectory targetDirectory = superClass.getContainingFile().getContainingDirectory(); final PsiPackage targetPackage = targetDirectory != null ? JavaDirectoryService.getInstance().getPackage(targetDirectory) : null; conflicts.putAllValues(GrPullUpConflictsUtil.checkConflicts(infos, mySubclass, superClass, targetPackage, targetDirectory, dialog.getContainmentVerifier())); }), RefactoringBundle.message("detecting.possible.conflicts"), true, myProject)) { return false; } if (!conflicts.isEmpty()) { ConflictsDialog conflictsDialog = new ConflictsDialog(myProject, conflicts); conflictsDialog.show(); final boolean ok = conflictsDialog.isOK(); if (!ok && conflictsDialog.isShowConflicts()) dialog.close(DialogWrapper.CANCEL_EXIT_CODE); return ok; } return true; } | checkConflicts |
31,828 | boolean (PsiClass superClass, GrMemberInfo[] infos) { if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, superClass)) return false; for (GrMemberInfo info : infos) { if (info.getMember() instanceof PsiClass && info.getOverrides() != null) continue; if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, info.getMember())) return false; } return true; } | checkWritable |
31,829 | boolean (PsiElement[] elements) { return elements.length == 1 && elements[0] instanceof PsiClass; } | isEnabledOnElements |
31,830 | PullUpHelper (PullUpData data) { return new GrPullUpHelper(data); } | createPullUpHelper |
31,831 | void (MemberInfo info) { GroovyChangeContextUtil.encodeContextInfo(info.getMember()); ((GroovyPsiElement)info.getMember()).accept(myQualifiedSearcher); } | encodeContextInfo |
31,832 | void (MemberInfo info, PsiSubstitutor substitutor) { if (info.getMember() instanceof PsiMethod) { doMoveMethod(substitutor, info); } else if (info.getMember() instanceof PsiField) { doMoveField(substitutor, info); } else if (info.getMember() instanceof PsiClass) { doMoveClass(substitutor, info); } } | move |
31,833 | void (PsiMember member) { ((GrMember)member).accept(myExplicitSuperDeleter); ((GrMember)member).accept(myThisSuperAdjuster); GroovyChangeContextUtil.decodeContextInfo(member, null, null); ((GroovyPsiElement)member).accept(new GroovyRecursiveElementVisitor() { @Override public void visitReferenceExpression(@NotNull GrReferenceExpression referenceExpression) { if (processRef(referenceExpression)) return; super.visitReferenceExpression(referenceExpression); } @Override public void visitCodeReferenceElement(@NotNull GrCodeReferenceElement refElement) { if (processRef(refElement)) return; super.visitCodeReferenceElement(refElement); } private static boolean processRef(@NotNull GrReferenceElement<? extends GroovyPsiElement> refElement) { final PsiElement qualifier = refElement.getQualifier(); if (qualifier != null) { final Boolean preserveQualifier = qualifier.getCopyableUserData(PRESERVE_QUALIFIER); if (preserveQualifier != null && !preserveQualifier) { refElement.setQualifier(null); return true; } } return false; } }); } | postProcessMember |
31,834 | void (@NotNull GrReferenceExpression referenceExpression) { if (processRef(referenceExpression)) return; super.visitReferenceExpression(referenceExpression); } | visitReferenceExpression |
31,835 | void (@NotNull GrCodeReferenceElement refElement) { if (processRef(refElement)) return; super.visitCodeReferenceElement(refElement); } | visitCodeReferenceElement |
31,836 | boolean (@NotNull GrReferenceElement<? extends GroovyPsiElement> refElement) { final PsiElement qualifier = refElement.getQualifier(); if (qualifier != null) { final Boolean preserveQualifier = qualifier.getCopyableUserData(PRESERVE_QUALIFIER); if (preserveQualifier != null && !preserveQualifier) { refElement.setQualifier(null); return true; } } return false; } | processRef |
31,837 | void (MemberInfo info) { PsiModifierListOwner modifierListOwner = info.getMember(); if (myTargetSuperClass.isInterface()) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PUBLIC, true); } else if (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE)) { if (info.isToAbstract() || willBeUsedInSubclass(modifierListOwner, myMembersToMove, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PROTECTED, true); } if (modifierListOwner instanceof GrTypeDefinition) { ((GrTypeDefinition)modifierListOwner).accept(new GroovyRecursiveElementVisitor() { @Override public void visitMethod(@NotNull GrMethod method) { check(method); } @Override public void visitField(@NotNull GrField field) { check(field); } @Override public void visitTypeDefinition(@NotNull GrTypeDefinition typeDefinition) { check(typeDefinition); super.visitTypeDefinition(typeDefinition); } private void check(PsiMember member) { if (member.hasModifierProperty(PsiModifier.PRIVATE)) { if (willBeUsedInSubclass(member, myMembersToMove, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(member, PsiModifier.PROTECTED, true); } } } }); } } } | setCorrectVisibility |
31,838 | void (@NotNull GrMethod method) { check(method); } | visitMethod |
31,839 | void (@NotNull GrField field) { check(field); } | visitField |
31,840 | void (@NotNull GrTypeDefinition typeDefinition) { check(typeDefinition); super.visitTypeDefinition(typeDefinition); } | visitTypeDefinition |
31,841 | void (PsiMember member) { if (member.hasModifierProperty(PsiModifier.PRIVATE)) { if (willBeUsedInSubclass(member, myMembersToMove, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(member, PsiModifier.PROTECTED, true); } } } | check |
31,842 | void (LinkedHashSet<PsiField> movedFields) { //todo } | moveFieldInitializations |
31,843 | void (PsiElement element) { if (element instanceof GrReferenceExpression) { GrExpression qualifierExpression = ((GrReferenceExpression)element).getQualifierExpression(); if (qualifierExpression instanceof GrReferenceExpression && ((GrReferenceExpression)qualifierExpression).resolve() == mySourceClass) { ((GrReferenceExpression)qualifierExpression).bindToElement(myTargetSuperClass); } } } | updateUsage |
31,844 | boolean (PsiElement member, Set<? extends PsiMember> movedMembers, PsiClass superclass, PsiClass subclass) { for (PsiReference ref : ReferencesSearch.search(member, new LocalSearchScope(subclass), false)) { PsiElement element = ref.getElement(); if (!RefactoringHierarchyUtil.willBeInTargetClass(element, movedMembers, superclass, false)) { return true; } } return false; } | willBeUsedInSubclass |
31,845 | void (PsiSubstitutor substitutor, MemberInfo info) { GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject); GrMethod method = (GrMethod)info.getMember(); PsiMethod sibling = method; PsiMethod anchor = null; while (sibling != null) { sibling = PsiTreeUtil.getNextSiblingOfType(sibling, PsiMethod.class); if (sibling != null) { anchor = MethodSignatureUtil.findMethodInSuperClassBySignatureInDerived(method.getContainingClass(), myTargetSuperClass, sibling.getSignature(PsiSubstitutor.EMPTY), false); if (anchor != null) { break; } } } GrMethod methodCopy = (GrMethod)method.copy(); if (method.findSuperMethods(myTargetSuperClass).length == 0) { deleteOverrideAnnotationIfFound(methodCopy); } final boolean isOriginalMethodAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT) || method.hasModifierProperty(PsiModifier.DEFAULT); if (myTargetSuperClass.isInterface() || info.isToAbstract()) { GroovyChangeContextUtil.clearContextInfo(method); RefactoringUtil.makeMethodAbstract(myTargetSuperClass, methodCopy); if (myTargetSuperClass.isInterface()) { PsiUtil.setModifierProperty(methodCopy, PsiModifier.ABSTRACT, false); } replaceMovedMemberTypeParameters(methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); final GrMethod movedElement = anchor != null ? (GrMethod)myTargetSuperClass.addBefore(methodCopy, anchor) : (GrMethod)myTargetSuperClass.add(methodCopy); JavaCodeStyleSettings styleSettings = JavaCodeStyleSettings.getInstance(method.getContainingFile()); if (styleSettings.INSERT_OVERRIDE_ANNOTATION) { if (PsiUtil.isLanguageLevel5OrHigher(mySourceClass) && !myTargetSuperClass.isInterface() || PsiUtil.isLanguageLevel6OrHigher(mySourceClass)) { new AddAnnotationFix(CommonClassNames.JAVA_LANG_OVERRIDE, method) .invoke(method.getProject(), null, mySourceClass.getContainingFile()); } } GrDocComment oldDoc = method.getDocComment(); if (oldDoc != null) { GrDocCommentUtil.setDocComment(movedElement, oldDoc); } myDocCommentPolicy.processCopiedJavaDoc(methodCopy.getDocComment(), oldDoc, isOriginalMethodAbstract); myMembersAfterMove.add(movedElement); if (isOriginalMethodAbstract) { deleteMemberWithDocComment(method); } } else { if (isOriginalMethodAbstract) { PsiUtil.setModifierProperty(myTargetSuperClass, PsiModifier.ABSTRACT, true); } fixReferencesToStatic(methodCopy); replaceMovedMemberTypeParameters(methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); final PsiMethod superClassMethod = myTargetSuperClass.findMethodBySignature(methodCopy, false); Language language = myTargetSuperClass.getLanguage(); final PsiMethod movedElement; if (superClassMethod != null && superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) { movedElement = (PsiMethod)superClassMethod.replace(convertMethodToLanguage(methodCopy, language)); } else { movedElement = anchor != null ? (PsiMethod)myTargetSuperClass.addBefore(convertMethodToLanguage(methodCopy, language), anchor) : (PsiMethod)myTargetSuperClass.add(convertMethodToLanguage(methodCopy, language)); myMembersAfterMove.add(movedElement); } if (movedElement instanceof GrMethod) { GrDocCommentUtil.setDocComment((GrDocCommentOwner)movedElement, method.getDocComment()); } deleteMemberWithDocComment(method); } } | doMoveMethod |
31,846 | void (GrDocCommentOwner docCommentOwner) { GrDocComment oldDoc = docCommentOwner.getDocComment(); if (oldDoc != null) { oldDoc.delete(); } docCommentOwner.delete(); } | deleteMemberWithDocComment |
31,847 | void (PsiMethod oMethod) { final PsiAnnotation annotation = AnnotationUtil.findAnnotation(oMethod, CommonClassNames.JAVA_LANG_OVERRIDE); if (annotation != null) { PsiElement prev = annotation.getPrevSibling(); PsiElement next = annotation.getNextSibling(); if ((prev == null || org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isLineFeed(prev)) && org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isLineFeed(next)) { next.delete(); } annotation.delete(); } } | deleteOverrideAnnotationIfFound |
31,848 | void (final PsiElement member, final Iterable<? extends PsiTypeParameter> parametersIterable, final PsiSubstitutor substitutor, final GroovyPsiElementFactory factory) { final Map<PsiElement, PsiElement> replacement = new LinkedHashMap<>(); for (PsiTypeParameter parameter : parametersIterable) { PsiType substitutedType = substitutor.substitute(parameter); PsiType type = substitutedType != null ? substitutedType : TypeConversionUtil.erasure(factory.createType(parameter)); PsiElement scopeElement = member instanceof GrField ? member.getParent() : member; for (PsiReference reference : ReferencesSearch.search(parameter, new LocalSearchScope(scopeElement))) { final PsiElement element = reference.getElement(); final PsiElement parent = element.getParent(); if (parent instanceof PsiTypeElement) { replacement.put(parent, factory.createTypeElement(type)); } else if (element instanceof GrCodeReferenceElement && type instanceof PsiClassType) { replacement.put(element, factory.createReferenceElementByType((PsiClassType)type)); } } } final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(member.getProject()); for (PsiElement element : replacement.keySet()) { if (element.isValid()) { final PsiElement replaced = element.replace(replacement.get(element)); codeStyleManager.shortenClassReferences(replaced); } } } | replaceMovedMemberTypeParameters |
31,849 | void (GrReferenceElement<?> ref, GrMember classMember, GroovyResolveResult resolveResult) { if (classMember.hasModifierProperty(PsiModifier.STATIC) /*&& classMemberReference.isQualified()*/) { if (!myMovedMembers.contains(classMember) && RefactoringHierarchyUtil.isMemberBetween(myTargetSuperClass, mySourceClass, classMember)) { results.add(new StaticReferenceResult( ref, classMember, classMember.getContainingClass(), resolveResult.isInvokedOnProperty() )); } else if (myMovedMembers.contains(classMember) || myMembersAfterMove.contains(classMember)) { results.add(new StaticReferenceResult( ref, classMember, myTargetSuperClass, resolveResult.isInvokedOnProperty() )); } } } | visitClassMemberReferenceElement |
31,850 | void (@NotNull GrReferenceExpression expression) { if(org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isSuperReference(expression.getQualifierExpression())) { PsiElement resolved = expression.resolve(); if (resolved == null || resolved instanceof PsiMethod && shouldFixSuper((PsiMethod) resolved)) { expression.setQualifier(null); } } else if (org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isSuperReference(expression)) { expression.replaceWithExpression(myThisExpression, true); } } | visitReferenceExpression |
31,851 | void (@NotNull GrTypeDefinition typeDefinition) { //do nothing } | visitTypeDefinition |
31,852 | boolean (PsiMethod method) { for (PsiMember element : myMembersAfterMove) { if (element instanceof PsiMethod member) { // if there is such member among moved members, super qualifier // should not be removed final PsiManager manager = method.getManager(); if (manager.areElementsEquivalent(member.getContainingClass(), method.getContainingClass()) && MethodSignatureUtil.areSignaturesEqual(member, method)) { return false; } } } final PsiMethod methodFromSuper = myTargetSuperClass.findMethodBySignature(method, false); return methodFromSuper == null; } | shouldFixSuper |
31,853 | void (@NotNull GrReferenceExpression expression) { super.visitReferenceExpression(expression); if (expression.getCopyableUserData(SUPER_REF) != null) { expression.putCopyableUserData(SUPER_REF, null); final GrExpression qualifier = expression.getQualifier(); if (qualifier instanceof GrReferenceExpression && ((GrReferenceExpression)qualifier).isReferenceTo(mySourceClass)) { try { GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(myProject); GrExpression newExpr = factory.createExpressionFromText(myTargetSuperClass.getName() + ".this", null); expression.replace(newExpr); } catch (IncorrectOperationException e) { LOG.error(e); } } } else if (expression.getCopyableUserData(THIS_REF) != null) { expression.putCopyableUserData(THIS_REF, null); final GrExpression qualifier = expression.getQualifier(); if (qualifier instanceof GrReferenceExpression && ((GrReferenceExpression)qualifier).isReferenceTo(mySourceClass)) { try { ((GrReferenceExpression)qualifier).bindToElement(myTargetSuperClass); GroovyChangeContextUtil.clearContextInfo(qualifier); } catch (IncorrectOperationException e) { LOG.error(e); } } } } | visitReferenceExpression |
31,854 | void (PsiSubstitutor substitutor, MemberInfo info) { GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject); GrField field = (GrField)info.getMember(); field.normalizeDeclaration(); replaceMovedMemberTypeParameters(field, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); fixReferencesToStatic(field); if (myTargetSuperClass.isInterface()) { PsiUtil.setModifierProperty(field, PsiModifier.PUBLIC, true); } final PsiMember movedElement = (PsiMember)myTargetSuperClass.add(convertFieldToLanguage(field, myTargetSuperClass.getLanguage())); myMembersAfterMove.add(movedElement); deleteMemberWithDocComment(field); } | doMoveField |
31,855 | void (PsiSubstitutor substitutor, MemberInfo info) { if (Boolean.FALSE.equals(info.getOverrides())) { PsiClass aClass = (PsiClass)info.getMember(); if (myTargetSuperClass instanceof GrTypeDefinition) { addClassToSupers(info, aClass, substitutor, (GrTypeDefinition)myTargetSuperClass); } } else { GrTypeDefinition aClass = (GrTypeDefinition)info.getMember(); GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject); replaceMovedMemberTypeParameters(aClass, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); fixReferencesToStatic(aClass); PsiMember movedElement = (PsiMember)myTargetSuperClass.addAfter(convertClassToLanguage(aClass, myTargetSuperClass.getLanguage()), null); myMembersAfterMove.add(movedElement); deleteMemberWithDocComment(aClass); } } | doMoveClass |
31,856 | PsiMethod (PsiMethod method, Language language) { if (method.getLanguage().equals(language)) { return method; } return JVMElementFactories.getFactory(language, method.getProject()).createMethodFromText(method.getText(), null); } | convertMethodToLanguage |
31,857 | PsiField (PsiField field, Language language) { if (field.getLanguage().equals(language)) { return field; } return JVMElementFactories.getFactory(language, field.getProject()).createField(field.getName(), field.getType()); } | convertFieldToLanguage |
31,858 | PsiClass (PsiClass clazz, Language language) { //if (clazz.getLanguage().equals(language)) { // return clazz; //} //PsiClass newClass = JVMElementFactories.getFactory(language, clazz.getProject()).createClass(clazz.getName()); return clazz; } | convertClassToLanguage |
31,859 | void (MemberInfo info, PsiClass aClass, PsiSubstitutor substitutor, GrTypeDefinition targetSuperClass) { final PsiReferenceList sourceReferenceList = info.getSourceReferenceList(); LOG.assertTrue(sourceReferenceList != null); PsiQualifiedReferenceElement ref = mySourceClass.equals(sourceReferenceList.getParent()) ? removeFromReferenceList(sourceReferenceList, aClass) : findReferenceToClass(sourceReferenceList, aClass); if (ref != null && !targetSuperClass.isInheritor(aClass, false)) { GroovyPsiElementFactory elementFactory = GroovyPsiElementFactory.getInstance(myProject); replaceMovedMemberTypeParameters(ref, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); GrReferenceList referenceList; if (targetSuperClass.isInterface()) { referenceList = targetSuperClass.getExtendsClause(); if (referenceList == null) { GrExtendsClause newClause = GroovyPsiElementFactory.getInstance(myProject).createExtendsClause(); PsiElement anchor = targetSuperClass.getTypeParameterList() != null ? targetSuperClass.getTypeParameterList(): targetSuperClass.getNameIdentifierGroovy(); referenceList = (GrReferenceList)targetSuperClass.addAfter(newClause, anchor); addSpacesAround(referenceList); } } else { referenceList = targetSuperClass.getImplementsClause(); if (referenceList == null) { GrImplementsClause newClause = GroovyPsiElementFactory.getInstance(myProject).createImplementsClause(); PsiElement anchor = targetSuperClass.getExtendsClause() != null ? targetSuperClass.getExtendsClause() : targetSuperClass.getTypeParameterList() != null ? targetSuperClass.getTypeParameterList() : targetSuperClass.getNameIdentifierGroovy(); referenceList = (GrReferenceList)targetSuperClass.addAfter(newClause, anchor); addSpacesAround(referenceList); } } referenceList.add(ref); } } | addClassToSupers |
31,860 | void (@NotNull GrReferenceList list) { PsiElement prev = list.getPrevSibling(); if (!PsiImplUtil.isWhiteSpaceOrNls(prev)) { list.getParent().getNode().addLeaf(TokenType.WHITE_SPACE, " ", list.getNode()); } PsiElement next = list.getNextSibling(); if (!PsiImplUtil.isWhiteSpaceOrNls(next)) { list.getParent().getNode().addLeaf(TokenType.WHITE_SPACE, " ", list.getNode().getTreeNext()); } } | addSpacesAround |
31,861 | PsiQualifiedReferenceElement (PsiReferenceList refList, PsiClass aClass) { PsiQualifiedReferenceElement[] refs = refList instanceof GrReferenceList ? ((GrReferenceList)refList).getReferenceElementsGroovy() : refList.getReferenceElements(); for (PsiQualifiedReferenceElement ref : refs) { if (ref.isReferenceTo(aClass)) { return ref; } } return null; } | findReferenceToClass |
31,862 | void (@NotNull GrReferenceExpression expression) { super.visitReferenceExpression(expression); if (org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isSuperReference(expression)) { final GrExpression qualifier = expression.getQualifier(); if (qualifier instanceof GrReferenceExpression && ((GrReferenceExpression)qualifier).isReferenceTo(mySourceClass)) { try { expression.putCopyableUserData(SUPER_REF, Boolean.TRUE); } catch (IncorrectOperationException e) { LOG.error(e); } } } else if (org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil.isThisReference(expression)) { final GrExpression qualifier = expression.getQualifier(); if (qualifier instanceof GrReferenceExpression && ((GrReferenceExpression)qualifier).isReferenceTo(mySourceClass)) { try { expression.putCopyableUserData(THIS_REF, Boolean.TRUE); } catch (IncorrectOperationException e) { LOG.error(e); } } } } | visitReferenceExpression |
31,863 | boolean (PsiMethod psiMethod) { return PullUpProcessor.checkedInterfacesContain(myMemberInfos, psiMethod); } | checkedInterfacesContain |
31,864 | int () { return myJavaDocPanel.getPolicy(); } | getJavaDocPolicy |
31,865 | String () { return "#com.intellij.refactoring.memberPullUp.PullUpDialog"; } | getDimensionServiceKey |
31,866 | void () { super.updateMemberInfo(); getRefactorAction().setEnabled(GroovyLanguage.INSTANCE.equals(getSuperClass().getLanguage())); ((MyMemberInfoModel)myMemberInfoModel).setSuperClass(getSuperClass()); myMemberSelectionPanel.getTable().setMemberInfos(myMemberInfos); myMemberSelectionPanel.getTable().fireExternalDataChange(); } | updateMemberInfo |
31,867 | void (JComboBox classCombo) { classCombo.setRenderer(new ClassCellRenderer(classCombo.getRenderer())); } | initClassCombo |
31,868 | PsiClass () { PsiClass preselection = RefactoringHierarchyUtil.getNearestBaseClass(myClass, false); final String statKey = PULL_UP_STATISTICS_KEY + myClass.getQualifiedName(); for (StatisticsInfo info : StatisticsManager.getInstance().getAllValues(statKey)) { final String superClassName = info.getValue(); PsiClass superClass = null; for (PsiClass aClass : mySuperClasses) { if (Comparing.strEqual(superClassName, aClass.getQualifiedName())) { superClass = aClass; break; } } if (superClass != null && StatisticsManager.getInstance().getUseCount(info) > 0) { preselection = superClass; break; } } return preselection; } | getPreselection |
31,869 | String () { return HelpID.MEMBERS_PULL_UP; } | getHelpId |
31,870 | void () { if (!myCallback.checkConflicts(this)) return; JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC = myJavaDocPanel.getPolicy(); final PsiClass superClass = getSuperClass(); String name = superClass.getQualifiedName(); if (name != null) { StatisticsManager.getInstance().incUseCount(new StatisticsInfo(PULL_UP_STATISTICS_KEY + myClass.getQualifiedName(), name)); } List<GrMemberInfo> infos = getSelectedMemberInfos(); //GrPullUpProcessor processor = new GrPullUpProcessor(myClass, superClass, infos.toArray(new GrMemberInfo[infos.size()]), new DocCommentPolicy(getJavaDocPolicy())); //invokeRefactoring(processor); close(OK_EXIT_CODE); } | doAction |
31,871 | void (JPanel panel) { myJavaDocPanel = new DocCommentPanel(JavaRefactoringBundle.message("javadoc.for.abstracts")); myJavaDocPanel.setPolicy(JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC); boolean hasJavadoc = false; for (GrMemberInfo info : myMemberInfos) { final PsiMember member = info.getMember(); if (myMemberInfoModel.isAbstractEnabled(info) && member instanceof PsiDocCommentOwner && ((PsiDocCommentOwner)member).getDocComment() != null) { hasJavadoc = true; break; } } UIUtil.setEnabled(myJavaDocPanel, hasJavadoc, true); panel.add(myJavaDocPanel, BorderLayout.EAST); } | addCustomElementsToCentralPanel |
31,872 | boolean (GrMemberInfo member) { PsiClass currentSuperClass = getSuperClass(); if(currentSuperClass == null) return true; if (myMemberInfoStorage.getDuplicatedMemberInfos(currentSuperClass).contains(member)) return false; if (myMemberInfoStorage.getExtending(currentSuperClass).contains(member.getMember())) return false; if (!currentSuperClass.isInterface()) return true; GrMember element = member.getMember(); if (element instanceof PsiClass && ((PsiClass) element).isInterface()) return true; if (element instanceof PsiField) { return element.hasModifierProperty(PsiModifier.STATIC); } if (element instanceof PsiMethod) { if (currentSuperClass.isInterface()) { final PsiSubstitutor superSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(currentSuperClass, myClass, PsiSubstitutor.EMPTY); final MethodSignature signature = ((PsiMethod)element).getSignature(superSubstitutor); final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySignature(currentSuperClass, signature, false); if (superClassMethod != null) return false; } return !element.hasModifierProperty(PsiModifier.STATIC); } return true; } | isMemberEnabled |
31,873 | boolean (GrMemberInfo member) { PsiClass currentSuperClass = getSuperClass(); if (currentSuperClass == null || !currentSuperClass.isInterface()) return true; return false; } | isAbstractEnabled |
31,874 | boolean (GrMemberInfo member) { PsiClass currentSuperClass = getSuperClass(); if(currentSuperClass == null) return false; if (currentSuperClass.isInterface()) { if (member.getMember() instanceof PsiMethod) { return true; } } return false; } | isAbstractWhenDisabled |
31,875 | int (@NotNull GrMemberInfo member) { if (member.isChecked()) return OK; PsiClass currentSuperClass = getSuperClass(); if (currentSuperClass != null && currentSuperClass.isInterface()) { PsiMember element = member.getMember(); if (element.hasModifierProperty(PsiModifier.STATIC)) { return super.checkForProblems(member); } return OK; } else { return super.checkForProblems(member); } } | checkForProblems |
31,876 | Boolean (GrMemberInfo member) { return Boolean.TRUE; } | isFixedAbstract |
31,877 | void (GrMember classMember, GrReferenceElement classMemberReference) { if (classMember != null && willBeMoved(classMember, movedMembers)) { boolean isAccessible = false; if (classMember.hasModifierProperty(PsiModifier.PRIVATE)) { isAccessible = true; } else if (classMember.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) && toDifferentPackage) { isAccessible = true; } if (isAccessible) { String message = GroovyBundle.message("pull.up.wont.be.accessible.from.the.subclass", RefactoringUIUtil.getDescription(abstractMethod, false), RefactoringUIUtil.getDescription(classMember, true)); conflicts.putValue(classMember, StringUtil.capitalize(message)); } } } | visitClassMemberReferenceElement |
31,878 | void (MemberInfoBase<? extends GrMember>[] infos, MultiMap<PsiElement, String> conflictsList) { for (MemberInfoBase<? extends GrMember> info : infos) { GrMember member = info.getMember(); if (member instanceof PsiField || member instanceof PsiClass) { if (!member.hasModifierProperty(PsiModifier.STATIC) && !(member instanceof PsiClass && ((PsiClass)member).isInterface())) { String message = JavaRefactoringBundle.message("0.is.not.static.it.cannot.be.moved.to.the.interface", RefactoringUIUtil.getDescription(member, false)); message = StringUtil.capitalize(message); conflictsList.putValue(member, message); } } if (member instanceof PsiField && ((PsiField)member).getInitializer() == null) { String message = JavaRefactoringBundle.message("0.is.not.initialized.in.declaration.such.fields.are.not.allowed.in.interfaces", RefactoringUIUtil.getDescription(member, false)); conflictsList.putValue(member, StringUtil.capitalize(message)); } } } | checkInterfaceTarget |
31,879 | void (PsiClass superClass, MemberInfoBase<? extends GrMember>[] infos, MultiMap<PsiElement, String> conflictsList) { for (MemberInfoBase<? extends GrMember> info : infos) { GrMember member = info.getMember(); boolean isConflict = false; if (member instanceof PsiField) { String name = member.getName(); isConflict = superClass.findFieldByName(name, false) != null; } else if (member instanceof PsiMethod) { PsiSubstitutor superSubstitutor = TypeConversionUtil .getSuperClassSubstitutor(superClass, member.getContainingClass(), PsiSubstitutor.EMPTY); MethodSignature signature = ((PsiMethod) member).getSignature(superSubstitutor); final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySignature(superClass, signature, false); isConflict = superClassMethod != null; } if (isConflict) { String message = RefactoringBundle.message("0.already.contains.a.1", RefactoringUIUtil.getDescription(superClass, false), RefactoringUIUtil.getDescription(member, false)); message = StringUtil.capitalize(message); conflictsList.putValue(superClass, message); } if (member instanceof PsiMethod method) { final PsiModifierList modifierList = method.getModifierList(); if (!modifierList.hasModifierProperty(PsiModifier.PRIVATE)) { for (PsiClass subClass : ClassInheritorsSearch.search(superClass)) { if (method.getContainingClass() != subClass) { MethodSignature signature = ((PsiMethod) member).getSignature(TypeConversionUtil.getSuperClassSubstitutor(superClass, subClass, PsiSubstitutor.EMPTY)); final PsiMethod wouldBeOverriden = MethodSignatureUtil.findMethodBySignature(subClass, signature, false); if (wouldBeOverriden != null && VisibilityUtil.compare(VisibilityUtil.getVisibilityModifier(wouldBeOverriden.getModifierList()), VisibilityUtil.getVisibilityModifier(modifierList)) > 0) { conflictsList.putValue(wouldBeOverriden, StringUtil.capitalize(RefactoringUIUtil.getDescription(method, true) + " in super class would clash with local method from " + RefactoringUIUtil.getDescription(subClass, true))); } } } } } } } | checkSuperclassMembers |
31,880 | boolean (PsiElement element, Set<GrMember> movedMembers) { PsiElement parent = element; while (parent != null) { if (movedMembers.contains(parent)) return true; parent = parent.getParent(); } return false; } | willBeMoved |
31,881 | void (GrMember classMember, GrReferenceElement ref) { if (classMember != null && !willBeMoved(classMember, myMovedMembers)) { final PsiClass containingClass = classMember.getContainingClass(); if (containingClass != null && !PsiUtil.isAccessibleFromPackage(classMember, myTargetPackage) && (classMember.hasModifierProperty(PsiModifier.PACKAGE_LOCAL) || classMember.hasModifierProperty(PsiModifier.PROTECTED) && !mySubClass.isInheritor(containingClass, true))) { myConflicts.putValue(myMember, RefactoringUIUtil.getDescription(classMember, true) + " won't be accessible"); } } } | visitClassMemberReferenceElement |
31,882 | void (GrMember classMember, GrReferenceElement ref) { if (classMember != null && RefactoringHierarchyUtil.isMemberBetween(mySuperClass, mySubclass, classMember)) { if (classMember.hasModifierProperty(PsiModifier.STATIC) && !willBeMoved(classMember, myMovedMembers)) { final boolean isAccessible = mySuperClass != null ? PsiUtil.isAccessible(classMember, mySuperClass, null) : myTargetPackage != null ? PsiUtil.isAccessibleFromPackage(classMember, myTargetPackage): classMember.hasModifierProperty(PsiModifier.PUBLIC); if (!isAccessible) { String message = RefactoringBundle.message("0.uses.1.which.is.not.accessible.from.the.superclass", RefactoringUIUtil.getDescription(myScope, false), RefactoringUIUtil.getDescription(classMember, true)); message = StringUtil.capitalize(message); myConflictsList.putValue(classMember, message); } return; } if (!myAbstractMethods.contains(classMember) && !willBeMoved(classMember, myMovedMembers)) { if (!existsInSuperClass(classMember)) { String message = RefactoringBundle.message("0.uses.1.which.is.not.moved.to.the.superclass", RefactoringUIUtil.getDescription(myScope, false), RefactoringUIUtil.getDescription(classMember, true)); message = StringUtil.capitalize(message); myConflictsList.putValue(classMember, message); } } } } | visitClassMemberReferenceElement |
31,883 | boolean (PsiElement classMember) { if (!(classMember instanceof PsiMethod method)) return false; if (myInterfaceContainmentVerifier.checkedInterfacesContain(method)) return true; if (mySuperClass == null) return false; final PsiMethod methodBySignature = mySuperClass.findMethodBySignature(method, true); return methodBySignature != null; } | existsInSuperClass |
31,884 | Settings (@NotNull final PsiElement element, @Nullable Editor editor, boolean invokedOnReference) { if (element instanceof GrField) { return GrInlineFieldUtil.inlineFieldSettings((GrField)element, editor, invokedOnReference); } else if (element instanceof GrMethod) { return GroovyInlineMethodUtil.inlineMethodSettings((GrMethod)element, editor, invokedOnReference); } else { if (element instanceof GrTypeDefinition) { return null; //todo inline to anonymous class, push members from super class } } if (element instanceof PsiMember) { String message = GroovyRefactoringBundle.message("cannot.inline.0.", getFullName(element)); CommonRefactoringUtil.showErrorHint(element.getProject(), editor, message, "", HelpID.INLINE_FIELD); return InlineHandler.Settings.CANNOT_INLINE_SETTINGS; } return null; } | prepareInlineElement |
31,885 | String (PsiElement psi) { final String name = DescriptiveNameUtil.getDescriptiveName(psi); return (UsageViewUtil.getType(psi) + " " + name).trim(); } | getFullName |
31,886 | void (@NotNull PsiElement element, @NotNull Settings settings) { final PsiElement owner = element.getParent().getParent(); if (element instanceof GrVariable && owner instanceof GrVariableDeclarationOwner) { ((GrVariableDeclarationOwner)owner).removeVariable(((GrVariable)element)); } if (element instanceof GrMethod) { element.delete(); } } | removeDefinition |
31,887 | Inliner (@NotNull PsiElement element, @NotNull Settings settings) { if (element instanceof GrVariable) { return new GrVariableInliner((GrVariable)element, settings); } if (element instanceof GrMethod) { return new GroovyMethodInliner((GrMethod)element); } return null; } | createInliner |
31,888 | boolean (Language l) { return GroovyLanguage.INSTANCE == l; } | isEnabledForLanguage |
31,889 | boolean (PsiElement element) { return PsiUtil.isLocalVariable(element); } | canInlineElement |
31,890 | void (final Project project, Editor editor, final PsiElement element) { invoke(project, editor, (GrVariable)element); } | inlineElement |
31,891 | void (final Project project, Editor editor, final GrVariable local) { final PsiReference invocationReference = editor != null ? TargetElementUtil.findReference(editor) : null; final InlineLocalVarSettings localVarSettings = createSettings(local, editor, invocationReference != null); if (localVarSettings == null) return; if (!CommonRefactoringUtil.checkReadOnlyStatus(project, local)) return; final GroovyInlineLocalProcessor processor = new GroovyInlineLocalProcessor(project, localVarSettings, local); processor.setPrepareSuccessfulSwingThreadCallback(() -> { //do nothing }); processor.run(); } | invoke |
31,892 | InlineLocalVarSettings (final GrVariable variable, Editor editor, boolean invokedOnReference) { final String localName = variable.getName(); final Project project = variable.getProject(); GrExpression initializer = null; Instruction writeInstr = null; GroovyControlFlow flow = null; //search for initializer to inline if (invokedOnReference) { LOG.assertTrue(editor != null, "null editor but invokedOnReference==true"); final PsiReference ref = TargetElementUtil.findReference(editor); LOG.assertTrue(ref != null); PsiElement cur = ref.getElement(); if (cur instanceof GrReferenceExpression) { GrControlFlowOwner controlFlowOwner; do { controlFlowOwner = ControlFlowUtils.findControlFlowOwner(cur); if (controlFlowOwner == null) break; flow = ControlFlowUtils.getGroovyControlFlow(controlFlowOwner); final List<BitSet> writes = ControlFlowUtils.inferWriteAccessMap(flow, variable); final PsiElement finalCur = cur; Instruction instruction = ControlFlowUtils.findInstruction(finalCur, flow.getFlow()); LOG.assertTrue(instruction != null); final BitSet prev = writes.get(instruction.num()); if (prev.cardinality() == 1) { writeInstr = flow.getFlow()[prev.nextSetBit(0)]; final PsiElement element = writeInstr.getElement(); if (element instanceof GrVariable) { initializer = ((GrVariable)element).getInitializerGroovy(); } else if (element instanceof GrReferenceExpression) { initializer = TypeInferenceHelper.getInitializerFor((GrReferenceExpression)element); } } PsiElement old_cur = cur; if (controlFlowOwner instanceof GrClosableBlock) { cur = controlFlowOwner; } else { PsiElement parent = controlFlowOwner.getParent(); if (parent instanceof GrMember) cur = ((GrMember)parent).getContainingClass(); } if (cur == old_cur) break; } while (initializer == null); } } else { flow = ControlFlowUtils.getGroovyControlFlow(ControlFlowUtils.findControlFlowOwner(variable)); initializer = variable.getInitializerGroovy(); writeInstr = ContainerUtil.find(flow.getFlow(), instruction -> instruction.getElement() == variable); } if (initializer == null || writeInstr == null) { String message = GroovyRefactoringBundle.message("cannot.find.a.single.definition.to.inline.local.var"); CommonRefactoringUtil.showErrorHint(variable.getProject(), editor, message, getInlineVariable(), HelpID.INLINE_VARIABLE); return null; } int writeInstructionNumber = writeInstr.num(); if (ApplicationManager.getApplication().isUnitTestMode()) { return new InlineLocalVarSettings(initializer, writeInstructionNumber, flow); } final String question = GroovyRefactoringBundle.message("inline.local.variable.prompt.0.1", localName); RefactoringMessageDialog dialog = new RefactoringMessageDialog(getInlineVariable(), question, HelpID.INLINE_VARIABLE, "OptionPane.questionIcon", true, project); if (dialog.showAndGet()) { return new InlineLocalVarSettings(initializer, writeInstructionNumber, flow); } return null; } | createSettings |
31,893 | String (PsiElement element) { return getInlineVariable(); } | getActionName |
31,894 | UsageViewDescriptor (UsageInfo @NotNull [] usages) { return new BaseUsageViewDescriptor(myLocal); } | createUsageViewDescriptor |
31,895 | boolean (@NotNull Ref<UsageInfo[]> refUsages) { final MultiMap<PsiElement, String> conflicts = new MultiMap<>(); final UsageInfo[] usages = refUsages.get(); for (UsageInfo usage : usages) { collectConflicts(usage.getReference(), conflicts); } return showConflicts(conflicts, usages); } | preprocessUsages |
31,896 | boolean (UsageInfo @NotNull [] usages) { for (UsageInfo usage : usages) { if (usage instanceof ClosureUsage) return true; } return false; } | isPreviewUsages |
31,897 | void (final PsiReference reference, final MultiMap<PsiElement, String> conflicts) { GrExpression expr = (GrExpression)reference.getElement(); if (PsiUtil.isAccessedForWriting(expr)) { conflicts.putValue(expr, GroovyRefactoringBundle.message("variable.is.accessed.for.writing", myLocal.getName())); } } | collectConflicts |
31,898 | void (final GrVariable variable, Instruction[] flow, final List<BitSet> writes, final int writeInstructionNumber, final ArrayList<UsageInfo> toInline) { for (Instruction instruction : flow) { final PsiElement element = instruction.getElement(); if (instruction instanceof ReadWriteVariableInstruction) { if (((ReadWriteVariableInstruction)instruction).isWrite()) continue; if (element instanceof GrVariable && element != variable) continue; if (!(element instanceof GrReferenceExpression ref)) continue; if (ref.isQualified() || ref.resolve() != variable) continue; final BitSet prev = writes.get(instruction.num()); if (writeInstructionNumber >= 0 && prev.cardinality() == 1 && prev.get(writeInstructionNumber)) { toInline.add(new UsageInfo(ref)); } else if (writeInstructionNumber == -1 && prev.cardinality() == 0) { toInline.add(new ClosureUsage(ref)); } } else if (element instanceof GrClosableBlock) { final BitSet prev = writes.get(instruction.num()); if (writeInstructionNumber >= 0 && prev.cardinality() == 1 && prev.get(writeInstructionNumber) || writeInstructionNumber == -1 && prev.cardinality() == 0) { final GroovyControlFlow closureFlow = ControlFlowUtils.getGroovyControlFlow((GrClosableBlock)element); collectRefs(variable, closureFlow.getFlow(), ControlFlowUtils.inferWriteAccessMap(closureFlow, variable), -1, toInline); } } else if (element instanceof GrAnonymousClassDefinition) { final BitSet prev = writes.get(instruction.num()); if (writeInstructionNumber >= 0 && prev.cardinality() == 1 && prev.get(writeInstructionNumber) || writeInstructionNumber == -1 && prev.cardinality() == 0) { ((GrAnonymousClassDefinition)element).acceptChildren(new GroovyRecursiveElementVisitor() { @Override public void visitField(@NotNull GrField field) { GrExpression initializer = field.getInitializerGroovy(); if (initializer != null) { GroovyControlFlow flow = ControlFlowBuilder.buildControlFlow(initializer); collectRefs(variable, flow.getFlow(), ControlFlowUtils.inferWriteAccessMap(flow, variable), -1, toInline); } } @Override public void visitMethod(@NotNull GrMethod method) { GrOpenBlock block = method.getBlock(); if (block != null) { GroovyControlFlow flow = ControlFlowUtils.getGroovyControlFlow(block); collectRefs(variable, flow.getFlow(), ControlFlowUtils.inferWriteAccessMap(flow, variable), -1, toInline); } } @Override public void visitClassInitializer(@NotNull GrClassInitializer initializer) { GrOpenBlock block = initializer.getBlock(); GroovyControlFlow flow = ControlFlowUtils.getGroovyControlFlow(block); collectRefs(variable, flow.getFlow(), ControlFlowUtils.inferWriteAccessMap(flow, variable), -1, toInline); } }); } } } } | collectRefs |
31,899 | void (@NotNull GrField field) { GrExpression initializer = field.getInitializerGroovy(); if (initializer != null) { GroovyControlFlow flow = ControlFlowBuilder.buildControlFlow(initializer); collectRefs(variable, flow.getFlow(), ControlFlowUtils.inferWriteAccessMap(flow, variable), -1, toInline); } } | visitField |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.