public static boolean nameCanBeImported(@NotNull String fqName, @NotNull PsiElement context) { final PsiClass containingClass = PsiTreeUtil.getParentOfType(context, PsiClass.class); if (containingClass != null) { if (fqName.equals(containingClass.getQualifiedName())) { return true; } final String shortName = ClassUtil.extractClassName(fqName); final PsiClass[] innerClasses = containingClass.getAllInnerClasses(); for (PsiClass innerClass : innerClasses) { if (innerClass.hasModifierProperty(PsiModifier.PRIVATE)) { continue; } if (innerClass.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)) { if (!ClassUtils.inSamePackage(innerClass, containingClass)) { continue; } } final String className = innerClass.getName(); if (shortName.equals(className)) { return false; } } PsiField field = containingClass.findFieldByName(shortName, false); if (field != null) { return false; } field = containingClass.findFieldByName(shortName, true); if (field != null && PsiUtil.isAccessible(containingClass.getProject(), field, containingClass, null)) { return false; } } final PsiJavaFile file = PsiTreeUtil.getParentOfType(context, PsiJavaFile.class); if (file == null) { return false; } if (hasExactImportConflict(fqName, file)) { return false; } if (hasOnDemandImportConflict(fqName, file, true)) { return false; } if (containsConflictingReference(file, fqName)) { return false; } if (containsConflictingClass(fqName, file)) { return false; } return !containsConflictingClassName(fqName, file); }
public PsiElement getOriginalElement() { final PsiClass containingClass = getContainingClass(); if (containingClass == null) return this; PsiClass originalClass = (PsiClass) containingClass.getOriginalElement(); PsiField originalField = originalClass.findFieldByName(getName(), false); return originalField != null ? originalField : this; }
public static void checkFieldConflicts( @Nullable PsiClass aClass, String newName, final Map<PsiElement, String> conflicts) { PsiField existingField = aClass != null ? aClass.findFieldByName(newName, true) : null; if (existingField != null) { if (aClass.equals(existingField.getContainingClass())) { String className = aClass instanceof PsiAnonymousClass ? RefactoringBundle.message("current.class") : RefactoringUIUtil.getDescription(aClass, false); final String conflict = RefactoringBundle.message( "field.0.is.already.defined.in.the.1", existingField.getName(), className); conflicts.put(existingField, conflict); } else { // method somewhere in base class if (!existingField.hasModifierProperty(PsiModifier.PRIVATE)) { String fieldInfo = PsiFormatUtil.formatVariable( existingField, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER, PsiSubstitutor.EMPTY); String className = RefactoringUIUtil.getDescription(existingField.getContainingClass(), false); final String descr = RefactoringBundle.message( "field.0.will.hide.field.1.of.the.base.class", newName, fieldInfo, className); conflicts.put(existingField, descr); } } } }
@Nullable private static PsiElement doResolveMember(PsiClass aClass, String memberName) { PsiMember member = aClass.findFieldByName(memberName, true); if (member != null) return member; PsiMethod[] methods = aClass.findMethodsByName(memberName, true); return methods.length == 0 ? null : methods[0]; }
@Override protected PsiReference[] getReferencesByElement( @NotNull PsiClass aClass, XmlAttributeValue xmlAttributeValue, ProcessingContext context) { final PsiField field = aClass.findFieldByName(xmlAttributeValue.getValue(), false); return field == null ? PsiReference.EMPTY_ARRAY : new PsiReference[] {new JavaFxIdReference(xmlAttributeValue, field)}; }
@Nullable private static PsiMethod existingClassIsCompatible(PsiClass aClass, List<ParameterChunk> params) { if (params.size() == 1) { final ParameterChunk parameterChunk = params.get(0); final PsiType paramType = parameterChunk.parameter.type; if (TypeConversionUtil.isPrimitiveWrapper(aClass.getQualifiedName())) { parameterChunk.setField(aClass.findFieldByName("value", false)); parameterChunk.setGetter(paramType.getCanonicalText() + "Value"); for (PsiMethod constructor : aClass.getConstructors()) { if (constructorIsCompatible(constructor, params)) return constructor; } } } final PsiMethod[] constructors = aClass.getConstructors(); PsiMethod compatibleConstructor = null; for (PsiMethod constructor : constructors) { if (constructorIsCompatible(constructor, params)) { compatibleConstructor = constructor; break; } } if (compatibleConstructor == null) { return null; } final PsiParameterList parameterList = compatibleConstructor.getParameterList(); final PsiParameter[] constructorParams = parameterList.getParameters(); for (int i = 0; i < constructorParams.length; i++) { final PsiParameter param = constructorParams[i]; final ParameterChunk parameterChunk = params.get(i); final PsiField field = findFieldAssigned(param, compatibleConstructor); if (field == null) { return null; } parameterChunk.setField(field); final PsiMethod getterForField = PropertyUtil.findGetterForField(field); if (getterForField != null) { parameterChunk.setGetter(getterForField.getName()); } final PsiMethod setterForField = PropertyUtil.findSetterForField(field); if (setterForField != null) { parameterChunk.setSetter(setterForField.getName()); } } return compatibleConstructor; }
@NotNull private static ExpectedTypeMatching preferByMemberName( @Nullable String expectedMemberName, @Nullable PsiType itemType) { if (expectedMemberName != null) { PsiClass itemClass = PsiUtil.resolveClassInClassTypeOnly(itemType); if (itemClass != null) { if (itemClass.findMethodsByName(expectedMemberName, true).length > 0 || itemClass.findFieldByName(expectedMemberName, true) != null || itemClass.findInnerClassByName(expectedMemberName, true) != null) { return ExpectedTypeMatching.expected; } } } return ExpectedTypeMatching.normal; }
public void checkMemberPlacementInTargetClassConflict( final PsiClass targetClass, final PsiMember movedMember) { if (movedMember instanceof PsiField) { String name = movedMember.getName(); final PsiField field = targetClass.findFieldByName(name, false); if (field != null) { String message = RefactoringBundle.message( "0.already.contains.field.1", RefactoringUIUtil.getDescription(targetClass, false), CommonRefactoringUtil.htmlEmphasize(name)); myConflicts.putValue(field, CommonRefactoringUtil.capitalize(message)); } } else if (movedMember instanceof PsiMethod) { /* final PsiModifierList modifierList = movedMember.getModifierList(); assert modifierList != null; if (!modifierList.hasModifierProperty(PsiModifier.ABSTRACT)) { PsiMethod method = (PsiMethod)movedMember; final PsiMethod overrider = targetClass.findMethodBySignature(method, false); if (overrider != null) { String message = RefactoringBundle.message("0.is.already.overridden.in.1", RefactoringUIUtil.getDescription(method, true), RefactoringUIUtil.getDescription(targetClass, false)); myConflicts.putValue(overrider, CommonRefactoringUtil.capitalize(message)); } } */ } else if (movedMember instanceof PsiClass) { PsiClass aClass = (PsiClass) movedMember; final String name = aClass.getName(); final PsiClass[] allInnerClasses = targetClass.getAllInnerClasses(); for (PsiClass innerClass : allInnerClasses) { if (innerClass.equals(movedMember)) continue; if (name.equals(innerClass.getName())) { String message = RefactoringBundle.message( "0.already.contains.inner.class.named.1", RefactoringUIUtil.getDescription(targetClass, false), CommonRefactoringUtil.htmlEmphasize(name)); myConflicts.putValue(innerClass, message); } } } }
public static Map<String, PsiElement> prepareDefaultNameToDeclaration( Project project, KotlinCoreEnvironment environment) { Map<String, PsiElement> nameToDeclaration = new HashMap<String, PsiElement>(); PsiClass java_util_Collections = findClass("java.util.Collections", project, environment); nameToDeclaration.put( "java::java.util.Collections.emptyList()", findMethod(java_util_Collections, "emptyList")); nameToDeclaration.put("java::java.util.Collections", java_util_Collections); PsiClass java_util_List = findClass("java.util.ArrayList", project, environment); nameToDeclaration.put( "java::java.util.List", findClass("java.util.List", project, environment)); nameToDeclaration.put("java::java.util.ArrayList", java_util_List); nameToDeclaration.put( "java::java.util.ArrayList.set()", java_util_List.findMethodsByName("set", true)[0]); nameToDeclaration.put( "java::java.util.ArrayList.get()", java_util_List.findMethodsByName("get", true)[0]); nameToDeclaration.put("java::java", findPackage("java", project)); nameToDeclaration.put("java::java.util", findPackage("java.util", project)); nameToDeclaration.put("java::java.lang", findPackage("java.lang", project)); nameToDeclaration.put( "java::java.lang.Object", findClass("java.lang.Object", project, environment)); nameToDeclaration.put( "java::java.lang.Comparable", findClass("java.lang.Comparable", project, environment)); PsiClass java_lang_System = findClass("java.lang.System", project, environment); nameToDeclaration.put("java::java.lang.System", java_lang_System); PsiMethod[] methods = findClass("java.io.PrintStream", project, environment).findMethodsByName("print", true); nameToDeclaration.put("java::java.io.PrintStream.print(Object)", methods[8]); nameToDeclaration.put("java::java.io.PrintStream.print(Int)", methods[2]); nameToDeclaration.put("java::java.io.PrintStream.print(char[])", methods[6]); nameToDeclaration.put("java::java.io.PrintStream.print(Double)", methods[5]); PsiField outField = java_lang_System.findFieldByName("out", true); assertNotNull("'out' property wasn't found", outField); nameToDeclaration.put("java::java.lang.System.out", outField); PsiClass java_lang_Number = findClass("java.lang.Number", project, environment); nameToDeclaration.put("java::java.lang.Number", java_lang_Number); nameToDeclaration.put( "java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]); return nameToDeclaration; }
private static boolean nameCanBeStaticallyImported( @NotNull String fqName, @NotNull String memberName, @NotNull PsiElement context) { final PsiClass containingClass = PsiTreeUtil.getParentOfType(context, PsiClass.class); if (containingClass == null) { return false; } if (InheritanceUtil.isInheritor(containingClass, fqName)) { return true; } final PsiField field = containingClass.findFieldByName(memberName, true); if (field != null) { return false; } final PsiMethod[] methods = containingClass.findMethodsByName(memberName, true); if (methods.length > 0) { return false; } return !hasOnDemandImportStaticConflict(fqName, memberName, context, true) && !hasExactImportStaticConflict(fqName, memberName, context); }
private static boolean hasOnDemandImportStaticConflict( String fqName, String memberName, PsiElement context, boolean strict) { final PsiFile file = context.getContainingFile(); if (!(file instanceof PsiJavaFile)) { return false; } final PsiJavaFile javaFile = (PsiJavaFile) file; final PsiImportList importList = javaFile.getImportList(); if (importList == null) { return false; } final PsiImportStaticStatement[] importStaticStatements = importList.getImportStaticStatements(); for (PsiImportStaticStatement importStaticStatement : importStaticStatements) { if (!importStaticStatement.isOnDemand()) { continue; } final PsiClass targetClass = importStaticStatement.resolveTargetClass(); if (targetClass == null) { continue; } final String name = targetClass.getQualifiedName(); if (fqName.equals(name)) { continue; } final PsiField field = targetClass.findFieldByName(memberName, true); if (field != null && (!strict || memberReferenced(field, javaFile))) { return true; } final PsiMethod[] methods = targetClass.findMethodsByName(memberName, true); if (methods.length > 0 && (!strict || membersReferenced(methods, javaFile))) { return true; } } return false; }
private static void findSubmemberHidesFieldCollisions( final PsiField field, final String newName, final List<UsageInfo> result) { if (field.getContainingClass() == null) return; if (field.hasModifierProperty(PsiModifier.PRIVATE)) return; final PsiClass containingClass = field.getContainingClass(); Collection<PsiClass> inheritors = ClassInheritorsSearch.search(containingClass).findAll(); for (PsiClass inheritor : inheritors) { PsiField conflictingField = inheritor.findFieldByName(newName, false); if (conflictingField != null) { result.add(new SubmemberHidesMemberUsageInfo(conflictingField, field)); } else { // local class final PsiMember member = PsiTreeUtil.getParentOfType(inheritor, PsiMember.class); if (member != null) { final ArrayList<PsiVariable> variables = new ArrayList<>(); ControlFlowUtil.collectOuterLocals(variables, inheritor, inheritor, member); for (PsiVariable variable : variables) { if (newName.equals(variable.getName())) { result.add(new FieldHidesLocalUsageInfo(variable, field)); } } } } } }
public void testFieldInJavadoc() throws Exception { PsiClass aClass = myJavaFacade.findClass("A", GlobalSearchScope.allScope(myProject)); PsiField field = aClass.findFieldByName("FIELD", false); doTest(field, new String[] {"A.java"}, new int[] {}, new int[] {}); }
@Override protected ExpectedResolveData getExpectedResolveData() { Project project = getProject(); JetStandardLibrary lib = JetStandardLibrary.getInstance(); Map<String, DeclarationDescriptor> nameToDescriptor = new HashMap<String, DeclarationDescriptor>(); nameToDescriptor.put( "kotlin::Int.plus(Int)", standardFunction(lib.getInt(), "plus", lib.getIntType())); FunctionDescriptor descriptorForGet = standardFunction( lib.getArray(), Collections.singletonList(new TypeProjection(lib.getIntType())), "get", lib.getIntType()); nameToDescriptor.put("kotlin::Array.get(Int)", descriptorForGet.getOriginal()); nameToDescriptor.put( "kotlin::Int.compareTo(Double)", standardFunction(lib.getInt(), "compareTo", lib.getDoubleType())); @NotNull FunctionDescriptor descriptorForSet = standardFunction( lib.getArray(), Collections.singletonList(new TypeProjection(lib.getIntType())), "set", lib.getIntType(), lib.getIntType()); nameToDescriptor.put("kotlin::Array.set(Int, Int)", descriptorForSet.getOriginal()); Map<String, PsiElement> nameToDeclaration = new HashMap<String, PsiElement>(); PsiClass java_util_Collections = findClass("java.util.Collections"); nameToDeclaration.put( "java::java.util.Collections.emptyList()", findMethod(java_util_Collections, "emptyList")); nameToDeclaration.put("java::java.util.Collections", java_util_Collections); PsiClass java_util_List = findClass("java.util.List"); nameToDeclaration.put("java::java.util.List", java_util_List); nameToDeclaration.put( "java::java.util.List.set()", java_util_List.findMethodsByName("set", true)[0]); nameToDeclaration.put( "java::java.util.List.get()", java_util_List.findMethodsByName("get", true)[0]); nameToDeclaration.put("java::java", findPackage("java")); nameToDeclaration.put("java::java.util", findPackage("java.util")); nameToDeclaration.put("java::java.lang", findPackage("java.lang")); nameToDeclaration.put("java::java.lang.Object", findClass("java.lang.Object")); PsiClass java_lang_System = findClass("java.lang.System"); nameToDeclaration.put("java::java.lang.System", java_lang_System); PsiMethod[] methods = findClass("java.io.PrintStream").findMethodsByName("print", true); nameToDeclaration.put("java::java.io.PrintStream.print(Object)", methods[8]); nameToDeclaration.put("java::java.io.PrintStream.print(Int)", methods[2]); nameToDeclaration.put("java::java.io.PrintStream.print(char[])", methods[6]); nameToDeclaration.put("java::java.io.PrintStream.print(Double)", methods[5]); nameToDeclaration.put( "java::java.lang.System.out", java_lang_System.findFieldByName("out", true)); PsiClass java_lang_Number = findClass("java.lang.Number"); nameToDeclaration.put("java::java.lang.Number", java_lang_Number); nameToDeclaration.put( "java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]); return new ExpectedResolveData(nameToDescriptor, nameToDeclaration) { @Override protected JetFile createJetFile(String fileName, String text) { return createCheckAndReturnPsiFile(fileName, text); } }; }
private static boolean processCachedMembersByName( @NotNull PsiClass aClass, @NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @Nullable Set<PsiClass> visited, PsiElement last, @NotNull PsiElement place, boolean isRaw, @NotNull PsiSubstitutor substitutor, @NotNull MembersMap value, String name, @NotNull LanguageLevel languageLevel) { final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY); PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) { final PsiField fieldByName = aClass.findFieldByName(name, false); if (fieldByName != null) { processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass); if (!processor.execute(fieldByName, state)) return false; } else { final Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allFieldsMap = value.get(MemberType.FIELD); final List<Pair<PsiMember, PsiSubstitutor>> list = allFieldsMap.get(name); if (list != null) { for (final Pair<PsiMember, PsiSubstitutor> candidate : list) { PsiMember candidateField = candidate.getFirst(); PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor( candidateField.getContainingClass(), candidate.getSecond(), aClass, substitutor, factory, languageLevel); processor.handleEvent( PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, candidateField.getContainingClass()); if (!processor.execute(candidateField, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false; } } } } if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) { if (last != null && last.getParent() == aClass) { if (last instanceof PsiClass) { if (!processor.execute(last, state)) return false; } // Parameters final PsiTypeParameterList list = aClass.getTypeParameterList(); if (list != null && !list.processDeclarations(processor, state, last, place)) return false; } if (!(last instanceof PsiReferenceList)) { final PsiClass classByName = aClass.findInnerClassByName(name, false); if (classByName != null) { processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass); if (!processor.execute(classByName, state)) return false; } else { Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allClassesMap = value.get(MemberType.CLASS); List<Pair<PsiMember, PsiSubstitutor>> list = allClassesMap.get(name); if (list != null) { for (final Pair<PsiMember, PsiSubstitutor> candidate : list) { PsiMember inner = candidate.getFirst(); PsiClass containingClass = inner.getContainingClass(); if (containingClass != null) { PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor( containingClass, candidate.getSecond(), aClass, substitutor, factory, languageLevel); processor.handleEvent( PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass); if (!processor.execute(inner, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false; } } } } } } if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) { if (processor instanceof MethodResolverProcessor) { final MethodResolverProcessor methodResolverProcessor = (MethodResolverProcessor) processor; if (methodResolverProcessor.isConstructor()) { final PsiMethod[] constructors = aClass.getConstructors(); methodResolverProcessor.handleEvent( PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass); for (PsiMethod constructor : constructors) { if (!methodResolverProcessor.execute(constructor, state)) return false; } return true; } } Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap = value.get(MemberType.METHOD); List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name); if (list != null) { for (final Pair<PsiMember, PsiSubstitutor> candidate : list) { ProgressIndicatorProvider.checkCanceled(); PsiMethod candidateMethod = (PsiMethod) candidate.getFirst(); if (processor instanceof MethodResolverProcessor) { if (candidateMethod.isConstructor() != ((MethodResolverProcessor) processor).isConstructor()) continue; } final PsiClass containingClass = candidateMethod.getContainingClass(); if (visited != null && visited.contains(candidateMethod.getContainingClass())) { continue; } PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor( containingClass, candidate.getSecond(), aClass, substitutor, factory, languageLevel); finalSubstitutor = checkRaw(isRaw, factory, candidateMethod, finalSubstitutor); processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass); if (!processor.execute(candidateMethod, state.put(PsiSubstitutor.KEY, finalSubstitutor))) return false; } if (visited != null) { for (Pair<PsiMember, PsiSubstitutor> aList : list) { visited.add(aList.getFirst().getContainingClass()); } } } } return true; }
@NotNull private static Set<String> findSingleImports( @NotNull final PsiJavaFile file, @NotNull String[] names, @NotNull final Set<String> onDemandImports, @NotNull Set<String> namesToImportStaticly) { final GlobalSearchScope resolveScope = file.getResolveScope(); Set<String> namesToUseSingle = new THashSet<String>(); final String thisPackageName = file.getPackageName(); final Set<String> implicitlyImportedPackages = new THashSet<String>(Arrays.asList(file.getImplicitlyImportedPackages())); final PsiManager manager = file.getManager(); for (String name : names) { String prefix = getPackageOrClassName(name); if (prefix.length() == 0) continue; final boolean isImplicitlyImported = implicitlyImportedPackages.contains(prefix); if (!onDemandImports.contains(prefix) && !isImplicitlyImported) continue; String shortName = PsiNameHelper.getShortClassName(name); String thisPackageClass = thisPackageName.length() > 0 ? thisPackageName + "." + shortName : shortName; if (JavaPsiFacade.getInstance(manager.getProject()).findClass(thisPackageClass, resolveScope) != null) { namesToUseSingle.add(name); continue; } if (!isImplicitlyImported) { String langPackageClass = JAVA_LANG_PACKAGE + "." + shortName; // TODO : JSP! if (JavaPsiFacade.getInstance(manager.getProject()) .findClass(langPackageClass, resolveScope) != null) { namesToUseSingle.add(name); continue; } } for (String onDemandName : onDemandImports) { if (prefix.equals(onDemandName)) continue; if (namesToImportStaticly.contains(name)) { PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()).findClass(onDemandName, resolveScope); if (aClass != null) { PsiField field = aClass.findFieldByName(shortName, true); if (field != null && field.hasModifierProperty(PsiModifier.STATIC)) { namesToUseSingle.add(name); } else { PsiClass inner = aClass.findInnerClassByName(shortName, true); if (inner != null && inner.hasModifierProperty(PsiModifier.STATIC)) { namesToUseSingle.add(name); } else { PsiMethod[] methods = aClass.findMethodsByName(shortName, true); for (PsiMethod method : methods) { if (method.hasModifierProperty(PsiModifier.STATIC)) { namesToUseSingle.add(name); } } } } } } else { PsiClass aClass = JavaPsiFacade.getInstance(manager.getProject()) .findClass(onDemandName + "." + shortName, resolveScope); if (aClass != null) { namesToUseSingle.add(name); } } } } return namesToUseSingle; }
private static boolean processDeclarationsInClassNotCached( @NotNull PsiClass aClass, @NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @Nullable Set<PsiClass> visited, PsiElement last, @NotNull PsiElement place, boolean isRaw, @NotNull LanguageLevel languageLevel) { if (visited == null) visited = new THashSet<PsiClass>(); if (!visited.add(aClass)) return true; processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass); final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY); final NameHint nameHint = processor.getHint(NameHint.KEY); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) { if (nameHint != null) { final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false); if (fieldByName != null && !processor.execute(fieldByName, state)) return false; } else { final PsiField[] fields = aClass.getFields(); for (final PsiField field : fields) { if (!processor.execute(field, state)) return false; } } } PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) { PsiSubstitutor baseSubstitutor = state.get(PsiSubstitutor.KEY); final PsiMethod[] methods = nameHint != null ? aClass.findMethodsByName(nameHint.getName(state), false) : aClass.getMethods(); for (final PsiMethod method : methods) { PsiSubstitutor finalSubstitutor = checkRaw(isRaw, factory, method, baseSubstitutor); ResolveState methodState = finalSubstitutor == baseSubstitutor ? state : state.put(PsiSubstitutor.KEY, finalSubstitutor); if (!processor.execute(method, methodState)) return false; } } if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) { if (last != null && last.getParent() == aClass) { // Parameters final PsiTypeParameterList list = aClass.getTypeParameterList(); if (list != null && !list.processDeclarations(processor, ResolveState.initial(), last, place)) return false; } if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) { // Inners if (nameHint != null) { final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false); if (inner != null) { if (!processor.execute(inner, state)) return false; } } else { final PsiClass[] inners = aClass.getInnerClasses(); for (final PsiClass inner : inners) { if (!processor.execute(inner, state)) return false; } } } } return last instanceof PsiReferenceList || processSuperTypes( aClass, processor, visited, last, place, state, isRaw, factory, languageLevel); }
protected void performRefactoring(@NotNull UsageInfo[] usageInfos) { final PsiClass psiClass = buildClass(); if (psiClass == null) return; if (delegationRequired) { buildDelegate(); } myExtractEnumProcessor.performEnumConstantTypeMigration(usageInfos); final Set<PsiMember> members = new HashSet<PsiMember>(); for (PsiMethod method : methods) { final PsiMethod member = psiClass.findMethodBySignature(method, false); if (member != null) { members.add(member); } } for (PsiField field : fields) { final PsiField member = psiClass.findFieldByName(field.getName(), false); if (member != null) { members.add(member); final PsiExpression initializer = member.getInitializer(); if (initializer != null) { final boolean[] moveInitializerToConstructor = new boolean[1]; initializer.accept( new JavaRecursiveElementWalkingVisitor() { @Override public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); final PsiElement resolved = expression.resolve(); if (resolved instanceof PsiField && !members.contains(resolved)) { moveInitializerToConstructor[0] = true; } } }); if (moveInitializerToConstructor[0]) { final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(myProject); PsiMethod[] constructors = psiClass.getConstructors(); if (constructors.length == 0) { final PsiMethod constructor = (PsiMethod) elementFactory.createConstructor().setName(psiClass.getName()); constructors = new PsiMethod[] {(PsiMethod) psiClass.add(constructor)}; } for (PsiMethod constructor : constructors) { MoveInstanceMembersUtil.moveInitializerToConstructor( elementFactory, constructor, member); } } } } } if (myGenerateAccessors) { final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4SourceClass(); for (PsiField field : visitor.getFieldsNeedingGetter()) { sourceClass.add(GenerateMembersUtil.generateGetterPrototype(field)); } for (PsiField field : visitor.getFieldsNeedingSetter()) { sourceClass.add(GenerateMembersUtil.generateSetterPrototype(field)); } } super.performRefactoring(usageInfos); if (myNewVisibility == null) return; for (PsiMember member : members) { VisibilityUtil.fixVisibility(UsageViewUtil.toElements(usageInfos), member, myNewVisibility); } }
private static void checkSuperclassMembers( PsiClass superClass, MemberInfoBase<? extends PsiMember>[] infos, MultiMap<PsiElement, String> conflictsList) { for (MemberInfoBase<? extends PsiMember> info : infos) { PsiMember 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 = CommonRefactoringUtil.capitalize(message); conflictsList.putValue(superClass, message); } if (member instanceof PsiMethod) { final PsiMethod method = (PsiMethod) member; 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, CommonRefactoringUtil.capitalize( RefactoringUIUtil.getDescription(method, true) + " in super class would clash with local method from " + RefactoringUIUtil.getDescription(subClass, true))); } } } } } } }
public static void createFieldAndAddAssignment( final @NotNull Project project, final @NotNull PsiClass targetClass, final @NotNull PsiMethod method, final @NotNull PsiParameter parameter, final @NotNull PsiType fieldType, final @NotNull String fieldName, final boolean isStatic, final boolean isFinal) throws IncorrectOperationException { PsiManager psiManager = PsiManager.getInstance(project); PsiElementFactory factory = JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory(); PsiField field = factory.createField(fieldName, fieldType); PsiModifierList modifierList = field.getModifierList(); if (modifierList == null) return; modifierList.setModifierProperty(PsiModifier.STATIC, isStatic); modifierList.setModifierProperty(PsiModifier.FINAL, isFinal); NullableNotNullManager.getInstance(project).copyNullableOrNotNullAnnotation(parameter, field); PsiCodeBlock methodBody = method.getBody(); if (methodBody == null) return; PsiStatement[] statements = methodBody.getStatements(); Ref<Pair<PsiField, Boolean>> anchorRef = new Ref<Pair<PsiField, Boolean>>(); int i = findFieldAssignmentAnchor(statements, anchorRef, targetClass, parameter); Pair<PsiField, Boolean> fieldAnchor = anchorRef.get(); String stmtText = fieldName + " = " + parameter.getName() + ";"; if (fieldName.equals(parameter.getName())) { @NonNls String prefix = isStatic ? targetClass.getName() == null ? "" : targetClass.getName() + "." : "this."; stmtText = prefix + stmtText; } PsiStatement assignmentStmt = factory.createStatementFromText(stmtText, methodBody); assignmentStmt = (PsiStatement) CodeStyleManager.getInstance(project).reformat(assignmentStmt); if (i == statements.length) { methodBody.add(assignmentStmt); } else { methodBody.addAfter(assignmentStmt, i > 0 ? statements[i - 1] : null); } if (fieldAnchor != null) { PsiVariable psiVariable = fieldAnchor.getFirst(); psiVariable.normalizeDeclaration(); } if (targetClass.findFieldByName(fieldName, false) == null) { if (fieldAnchor != null) { Boolean insertBefore = fieldAnchor.getSecond(); PsiField inField = fieldAnchor.getFirst(); if (insertBefore.booleanValue()) { targetClass.addBefore(field, inField); } else { targetClass.addAfter(field, inField); } } else { targetClass.add(field); } } }