private static void addDefaultConstructor(
JavaChangeInfo changeInfo, PsiClass aClass, final UsageInfo[] usages)
throws IncorrectOperationException {
if (!(aClass instanceof PsiAnonymousClass)) {
PsiElementFactory factory = JavaPsiFacade.getElementFactory(aClass.getProject());
PsiMethod defaultConstructor =
factory.createMethodFromText(aClass.getName() + "(){}", aClass);
defaultConstructor =
(PsiMethod)
CodeStyleManager.getInstance(aClass.getProject()).reformat(defaultConstructor);
defaultConstructor = (PsiMethod) aClass.add(defaultConstructor);
PsiUtil.setModifierProperty(
defaultConstructor, VisibilityUtil.getVisibilityModifier(aClass.getModifierList()), true);
addSuperCall(changeInfo, defaultConstructor, null, usages);
} else {
final PsiElement parent = aClass.getParent();
if (parent instanceof PsiNewExpression) {
final PsiExpressionList argumentList = ((PsiNewExpression) parent).getArgumentList();
final PsiClass baseClass = changeInfo.getMethod().getContainingClass();
final PsiSubstitutor substitutor =
TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY);
fixActualArgumentsList(argumentList, changeInfo, true, substitutor);
}
}
}
@Override
protected void invokeImpl(final PsiClass targetClass) {
PsiNewExpression newExpression = getNewExpression();
PsiJavaCodeReferenceElement ref = newExpression.getClassOrAnonymousClassReference();
assert ref != null;
String refName = ref.getReferenceName();
LOG.assertTrue(refName != null);
PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(newExpression.getProject()).getElementFactory();
PsiClass created = elementFactory.createClass(refName);
final PsiModifierList modifierList = created.getModifierList();
LOG.assertTrue(modifierList != null);
if (PsiTreeUtil.isAncestor(targetClass, newExpression, true)) {
if (targetClass.isInterface()) {
modifierList.setModifierProperty(PsiModifier.PACKAGE_LOCAL, true);
} else {
modifierList.setModifierProperty(PsiModifier.PRIVATE, true);
}
}
if (!PsiTreeUtil.isAncestor(targetClass, newExpression, true)
|| PsiUtil.getEnclosingStaticElement(newExpression, targetClass) != null
|| isInThisOrSuperCall(newExpression)) {
modifierList.setModifierProperty(PsiModifier.STATIC, true);
}
created = (PsiClass) targetClass.add(created);
setupClassFromNewExpression(created, newExpression);
setupGenericParameters(created, ref);
}
public void buildReferences() {
PsiClass psiClass = getElement();
if (psiClass != null) {
for (PsiClassInitializer classInitializer : psiClass.getInitializers()) {
RefJavaUtil.getInstance().addReferences(psiClass, this, classInitializer.getBody());
}
RefJavaUtil.getInstance().addReferences(psiClass, this, psiClass.getModifierList());
PsiField[] psiFields = psiClass.getFields();
for (PsiField psiField : psiFields) {
getRefManager().getReference(psiField);
final PsiExpression initializer = psiField.getInitializer();
if (initializer != null) {
RefJavaUtil.getInstance().addReferences(psiClass, this, initializer);
}
}
PsiMethod[] psiMethods = psiClass.getMethods();
for (PsiMethod psiMethod : psiMethods) {
getRefManager().getReference(psiMethod);
}
getRefManager().fireBuildReferences(this);
}
}
@Override
public Result<PsiModifierList> compute() {
List<PsiModifierList> list = new ArrayList<PsiModifierList>();
for (PsiDirectory directory : getDirectories()) {
PsiFile file = directory.findFile(PACKAGE_INFO_FILE);
if (file != null) {
PsiPackageStatement stmt = PsiTreeUtil.getChildOfType(file, PsiPackageStatement.class);
if (stmt != null) {
final PsiModifierList modifierList = stmt.getAnnotationList();
if (modifierList != null) {
list.add(modifierList);
}
}
}
}
final JavaPsiFacade facade = getFacade();
final GlobalSearchScope scope = allScope();
for (PsiClass aClass : facade.findClasses(getQualifiedName() + ".package-info", scope)) {
ContainerUtil.addIfNotNull(aClass.getModifierList(), list);
}
return new Result<PsiModifierList>(
list.isEmpty() ? null : new PsiCompositeModifierList(getManager(), list),
OOCB_DEPENDENCY);
}
public LineMarkerInfo getLineMarkerInfo(@NotNull PsiElement element) {
if (ApplicationManager.getApplication().isUnitTestMode()) {
return null;
}
if (!(element instanceof PsiMethod) && !(element instanceof PsiClass)) {
return null;
}
if (!PsiUtil.isPluginProject(element.getProject())) {
return null;
}
final VirtualFile file = PsiUtilCore.getVirtualFile(element);
if (file == null
|| !ProjectFileIndex.SERVICE
.getInstance(element.getProject())
.isInTestSourceContent(file)) {
return null;
}
if (element instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) element;
if (isTestMethod(method)) {
return new LineMarkerInfo<PsiMethod>(
method,
method.getModifierList().getTextRange(),
PlatformIcons.TEST_SOURCE_FOLDER,
Pass.UPDATE_ALL,
null,
new TestDataNavigationHandler(),
GutterIconRenderer.Alignment.LEFT);
}
} else {
final PsiClass psiClass = (PsiClass) element;
final String basePath = getTestDataBasePath(psiClass);
if (basePath != null) {
PsiModifierList modifierList = psiClass.getModifierList();
assert modifierList != null;
return new LineMarkerInfo<PsiClass>(
psiClass,
modifierList.getTextRange(),
PlatformIcons.TEST_SOURCE_FOLDER,
Pass.UPDATE_ALL,
new TooltipProvider(basePath),
new GutterIconNavigationHandler<PsiClass>() {
@Override
public void navigate(MouseEvent e, PsiClass elt) {
final VirtualFile baseDir = VfsUtil.findFileByIoFile(new File(basePath), true);
if (baseDir != null) {
new OpenFileDescriptor(psiClass.getProject(), baseDir).navigate(true);
}
}
},
GutterIconRenderer.Alignment.LEFT);
}
}
return null;
}
/**
* Returns a set of targets where the given annotation may be applied, or {@code null} when the
* type is not a valid annotation.
*/
@Nullable
public static Set<TargetType> getAnnotationTargets(@NotNull PsiClass annotationType) {
if (!annotationType.isAnnotationType()) return null;
PsiModifierList modifierList = annotationType.getModifierList();
if (modifierList == null) return null;
PsiAnnotation target =
modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_TARGET);
if (target == null)
return DEFAULT_TARGETS; // if omitted it is applicable to all but Java 8
// TYPE_USE/TYPE_PARAMETERS targets
return extractRequiredAnnotationTargets(target.findAttributeValue(null));
}
public void testReplaceAnnotation() throws Exception {
// be sure not to load tree
getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.ALL);
PsiClass aClass = myJavaFacade.findClass("Test", GlobalSearchScope.allScope(myProject));
assertNotNull(aClass);
final PsiAnnotation[] annotations = aClass.getModifierList().getAnnotations();
assertEquals(1, annotations.length);
assertEquals("A", annotations[0].getNameReferenceElement().getReferenceName());
final PsiAnnotation newAnnotation =
myJavaFacade.getElementFactory().createAnnotationFromText("@B", null);
// here the tree is going to be loaded
getJavaFacade().setAssertOnFileLoadingFilter(VirtualFileFilter.NONE);
CommandProcessor.getInstance()
.executeCommand(
myProject,
new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
try {
annotations[0].replace(newAnnotation);
} catch (IncorrectOperationException e) {
LOGGER.error(e);
}
}
});
}
},
null,
null);
assertEquals("@B", aClass.getModifierList().getText());
}
public static boolean isAnnotatedCheckHierarchyWithCache(
@NotNull PsiClass aClass, @NotNull String annotationFQN) {
Map<String, PsiClass> classMap = getSuperClassesWithCache(aClass);
for (PsiClass psiClass : classMap.values()) {
PsiModifierList modifierList = psiClass.getModifierList();
if (modifierList != null) {
if (modifierList.findAnnotation(annotationFQN) != null) {
return true;
}
}
}
return false;
}
// returns contained element
private static PsiClass contained(PsiClass annotationType) {
if (!annotationType.isAnnotationType()) return null;
PsiMethod[] values = annotationType.findMethodsByName("value", false);
if (values.length != 1) return null;
PsiMethod value = values[0];
PsiType returnType = value.getReturnType();
if (!(returnType instanceof PsiArrayType)) return null;
PsiType type = ((PsiArrayType) returnType).getComponentType();
if (!(type instanceof PsiClassType)) return null;
PsiClass contained = ((PsiClassType) type).resolve();
if (contained == null || !contained.isAnnotationType()) return null;
if (PsiImplUtil.findAnnotation(
contained.getModifierList(), CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE)
== null) return null;
return contained;
}
public static void addImportIfNeeded(@NotNull PsiClass aClass, @NotNull PsiElement context) {
final PsiFile file = context.getContainingFile();
if (!(file instanceof PsiJavaFile)) {
return;
}
final PsiJavaFile javaFile = (PsiJavaFile) file;
final PsiClass outerClass = aClass.getContainingClass();
if (outerClass == null) {
if (PsiTreeUtil.isAncestor(javaFile, aClass, true)) {
return;
}
} else {
if (PsiTreeUtil.isAncestor(outerClass, context, true)
&& !PsiTreeUtil.isAncestor(outerClass.getModifierList(), context, true)) {
return;
}
}
final String qualifiedName = aClass.getQualifiedName();
if (qualifiedName == null) {
return;
}
final PsiImportList importList = javaFile.getImportList();
if (importList == null) {
return;
}
final String containingPackageName = javaFile.getPackageName();
@NonNls final String packageName = ClassUtil.extractPackageName(qualifiedName);
if (containingPackageName.equals(packageName)
|| importList.findSingleClassImportStatement(qualifiedName) != null) {
return;
}
if (importList.findOnDemandImportStatement(packageName) != null
&& !hasDefaultImportConflict(qualifiedName, javaFile)
&& !hasOnDemandImportConflict(qualifiedName, javaFile)) {
return;
}
final Project project = importList.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiElementFactory elementFactory = psiFacade.getElementFactory();
final PsiImportStatement importStatement = elementFactory.createImportStatement(aClass);
importList.add(importStatement);
}
@Override
public void visitClass(@NotNull PsiClass aClass) {
if (!aClass.isEnum()) {
return;
}
if (!ClassUtils.isInnerClass(aClass)) {
return;
}
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
return;
}
final PsiModifierList modifiers = aClass.getModifierList();
if (modifiers == null) {
return;
}
final PsiElement[] children = modifiers.getChildren();
for (final PsiElement child : children) {
final String text = child.getText();
if (PsiModifier.STATIC.equals(text)) {
registerError(child, child, aClass);
}
}
}
@Nullable
private static RetentionPolicy getRetentionPolicy(PsiClass annotation) {
PsiModifierList modifierList = annotation.getModifierList();
if (modifierList != null) {
PsiAnnotation retentionAnno =
modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION);
if (retentionAnno == null) return RetentionPolicy.CLASS;
PsiAnnotationMemberValue policyRef = PsiImplUtil.findAttributeValue(retentionAnno, null);
if (policyRef instanceof PsiReference) {
PsiElement field = ((PsiReference) policyRef).resolve();
if (field instanceof PsiEnumConstant) {
String name = ((PsiEnumConstant) field).getName();
try {
return RetentionPolicy.valueOf(name);
} catch (Exception e) {
LOG.warn("Unknown policy: " + name);
}
}
}
}
return null;
}
static HighlightInfo checkDuplicateAnnotations(@NotNull PsiAnnotation annotationToCheck) {
PsiAnnotationOwner owner = annotationToCheck.getOwner();
if (owner == null) return null;
PsiJavaCodeReferenceElement element = annotationToCheck.getNameReferenceElement();
if (element == null) return null;
PsiElement resolved = element.resolve();
if (!(resolved instanceof PsiClass)) return null;
PsiClass annotationType = (PsiClass) resolved;
PsiClass contained = contained(annotationType);
String containedElementFQN = contained == null ? null : contained.getQualifiedName();
if (containedElementFQN != null) {
PsiClass container = annotationType;
String containerName = container.getQualifiedName();
if (isAnnotationRepeatedTwice(owner, containedElementFQN)) {
String description =
JavaErrorMessages.message("annotation.container.wrong.place", containerName);
return annotationError(annotationToCheck, description);
}
} else if (isAnnotationRepeatedTwice(owner, annotationType.getQualifiedName())) {
if (!PsiUtil.isLanguageLevel8OrHigher(annotationToCheck)) {
String description = JavaErrorMessages.message("annotation.duplicate.annotation");
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(element)
.descriptionAndTooltip(description)
.create();
}
PsiAnnotation metaAnno =
PsiImplUtil.findAnnotation(
annotationType.getModifierList(), CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE);
if (metaAnno == null) {
String explanation =
JavaErrorMessages.message(
"annotation.non.repeatable", annotationType.getQualifiedName());
String description =
JavaErrorMessages.message("annotation.duplicate.explained", explanation);
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(element)
.descriptionAndTooltip(description)
.create();
}
String explanation = doCheckRepeatableAnnotation(metaAnno);
if (explanation != null) {
String description =
JavaErrorMessages.message("annotation.duplicate.explained", explanation);
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(element)
.descriptionAndTooltip(description)
.create();
}
PsiClass container = getRepeatableContainer(metaAnno);
if (container != null) {
PsiAnnotation.TargetType[] targets = PsiImplUtil.getTargetsForLocation(owner);
PsiAnnotation.TargetType applicable = PsiImplUtil.findApplicableTarget(container, targets);
if (applicable == null) {
String target = JavaErrorMessages.message("annotation.target." + targets[0]);
String message =
JavaErrorMessages.message(
"annotation.container.not.applicable", container.getName(), target);
return annotationError(annotationToCheck, message);
}
}
}
for (PsiAnnotation annotation : owner.getAnnotations()) {
if (annotation == annotationToCheck) continue;
PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
if (nameRef == null) continue;
PsiElement aClass = nameRef.resolve();
if (!resolved.equals(aClass)) continue;
}
return null;
}
private void tryToMoveInitializers(
PsiMethod constructor,
HashSet<PsiMethod> subConstructors,
LinkedHashSet<PsiField> movedFields)
throws IncorrectOperationException {
final LinkedHashMap<PsiField, Initializer> fieldsToInitializers =
new LinkedHashMap<PsiField, Initializer>();
boolean anyFound = false;
for (PsiField field : movedFields) {
PsiStatement commonInitializer = null;
final ArrayList<PsiElement> fieldInitializersToRemove = new ArrayList<PsiElement>();
for (PsiMethod subConstructor : subConstructors) {
commonInitializer =
hasCommonInitializer(
commonInitializer, subConstructor, field, fieldInitializersToRemove);
if (commonInitializer == null) break;
}
if (commonInitializer != null) {
final ParametersAndMovedFieldsUsedCollector visitor =
new ParametersAndMovedFieldsUsedCollector(movedFields);
commonInitializer.accept(visitor);
fieldsToInitializers.put(
field,
new Initializer(
commonInitializer,
visitor.getUsedFields(),
visitor.getUsedParameters(),
fieldInitializersToRemove));
anyFound = true;
}
}
if (!anyFound) return;
{
final Set<PsiField> initializedFields = fieldsToInitializers.keySet();
Set<PsiField> unmovable =
RefactoringUtil.transitiveClosure(
new RefactoringUtil.Graph<PsiField>() {
public Set<PsiField> getVertices() {
return initializedFields;
}
public Set<PsiField> getTargets(PsiField source) {
return fieldsToInitializers.get(source).movedFieldsUsed;
}
},
new Condition<PsiField>() {
public boolean value(PsiField object) {
return !initializedFields.contains(object);
}
});
for (PsiField psiField : unmovable) {
fieldsToInitializers.remove(psiField);
}
}
final PsiElementFactory factory = JavaPsiFacade.getElementFactory(myProject);
if (constructor == null) {
constructor = (PsiMethod) myTargetSuperClass.add(factory.createConstructor());
final String visibilityModifier =
VisibilityUtil.getVisibilityModifier(myTargetSuperClass.getModifierList());
PsiUtil.setModifierProperty(constructor, visibilityModifier, true);
}
ArrayList<PsiField> initializedFields = new ArrayList<PsiField>(fieldsToInitializers.keySet());
Collections.sort(
initializedFields,
new Comparator<PsiField>() {
public int compare(PsiField field1, PsiField field2) {
Initializer i1 = fieldsToInitializers.get(field1);
Initializer i2 = fieldsToInitializers.get(field2);
if (i1.movedFieldsUsed.contains(field2)) return 1;
if (i2.movedFieldsUsed.contains(field1)) return -1;
return 0;
}
});
for (final PsiField initializedField : initializedFields) {
Initializer initializer = fieldsToInitializers.get(initializedField);
// correct constructor parameters and subConstructors super calls
final PsiParameterList parameterList = constructor.getParameterList();
for (final PsiParameter parameter : initializer.usedParameters) {
parameterList.add(parameter);
}
for (final PsiMethod subConstructor : subConstructors) {
modifySuperCall(subConstructor, initializer.usedParameters);
}
PsiStatement assignmentStatement =
(PsiStatement) constructor.getBody().add(initializer.initializer);
PsiManager manager = PsiManager.getInstance(myProject);
ChangeContextUtil.decodeContextInfo(
assignmentStatement,
myTargetSuperClass,
RefactoringChangeUtil.createThisExpression(manager, null));
for (PsiElement psiElement : initializer.statementsToRemove) {
psiElement.delete();
}
}
}
public boolean processUsage(
ChangeInfo changeInfo, UsageInfo usage, boolean beforeMethodChange, UsageInfo[] usages) {
if (!isJavaUsage(usage)) return false;
if (!(changeInfo instanceof JavaChangeInfo)) return false;
if (beforeMethodChange) {
if (usage instanceof CallerUsageInfo) {
final CallerUsageInfo callerUsageInfo = (CallerUsageInfo) usage;
processCallerMethod(
(JavaChangeInfo) changeInfo,
callerUsageInfo.getMethod(),
null,
callerUsageInfo.isToInsertParameter(),
callerUsageInfo.isToInsertException());
return true;
} else if (usage instanceof OverriderUsageInfo) {
OverriderUsageInfo info = (OverriderUsageInfo) usage;
final PsiMethod method = info.getElement();
final PsiMethod baseMethod = info.getBaseMethod();
if (info.isOriginalOverrider()) {
processPrimaryMethod((JavaChangeInfo) changeInfo, method, baseMethod, false);
} else {
processCallerMethod(
(JavaChangeInfo) changeInfo,
method,
baseMethod,
info.isToInsertArgs(),
info.isToCatchExceptions());
}
return true;
}
} else {
PsiElement element = usage.getElement();
LOG.assertTrue(element != null);
if (usage instanceof DefaultConstructorImplicitUsageInfo) {
final DefaultConstructorImplicitUsageInfo defConstructorUsage =
(DefaultConstructorImplicitUsageInfo) usage;
PsiMethod constructor = defConstructorUsage.getConstructor();
if (!constructor.isPhysical()) {
final boolean toPropagate =
changeInfo instanceof JavaChangeInfoImpl
&& ((JavaChangeInfoImpl) changeInfo)
.propagateParametersMethods.remove(constructor);
final PsiClass containingClass = defConstructorUsage.getContainingClass();
constructor = (PsiMethod) containingClass.add(constructor);
PsiUtil.setModifierProperty(
constructor,
VisibilityUtil.getVisibilityModifier(containingClass.getModifierList()),
true);
if (toPropagate) {
((JavaChangeInfoImpl) changeInfo).propagateParametersMethods.add(constructor);
}
}
addSuperCall(
(JavaChangeInfo) changeInfo,
constructor,
defConstructorUsage.getBaseConstructor(),
usages);
return true;
} else if (usage instanceof NoConstructorClassUsageInfo) {
addDefaultConstructor(
((JavaChangeInfo) changeInfo),
((NoConstructorClassUsageInfo) usage).getPsiClass(),
usages);
return true;
} else if (usage instanceof MethodCallUsageInfo) {
final MethodCallUsageInfo methodCallInfo = (MethodCallUsageInfo) usage;
processMethodUsage(
methodCallInfo.getElement(),
(JavaChangeInfo) changeInfo,
methodCallInfo.isToChangeArguments(),
methodCallInfo.isToCatchExceptions(),
methodCallInfo.getReferencedMethod(),
methodCallInfo.getSubstitutor(),
usages);
return true;
} else if (usage instanceof ChangeSignatureParameterUsageInfo) {
String newName = ((ChangeSignatureParameterUsageInfo) usage).newParameterName;
String oldName = ((ChangeSignatureParameterUsageInfo) usage).oldParameterName;
processParameterUsage((PsiReferenceExpression) element, oldName, newName);
return true;
} else if (usage instanceof CallReferenceUsageInfo) {
((CallReferenceUsageInfo) usage).getReference().handleChangeSignature(changeInfo);
return true;
} else if (element instanceof PsiEnumConstant) {
fixActualArgumentsList(
((PsiEnumConstant) element).getArgumentList(),
(JavaChangeInfo) changeInfo,
true,
PsiSubstitutor.EMPTY);
return true;
} else if (!(usage instanceof OverriderUsageInfo)) {
PsiReference reference =
usage instanceof MoveRenameUsageInfo ? usage.getReference() : element.getReference();
if (reference != null) {
PsiElement target = changeInfo.getMethod();
if (target != null) {
reference.bindToElement(target);
}
}
}
}
return false;
}
@NotNull
public Class classToClass(@NotNull PsiClass psiClass) {
Set<String> modifiers = modifiersListToModifiersSet(psiClass.getModifierList());
List<Field> fields = fieldsToFieldList(psiClass.getFields(), psiClass);
List<Element> typeParameters = elementsToElementList(psiClass.getTypeParameters());
List<Type> implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes());
List<Type> extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes());
IdentifierImpl name = new IdentifierImpl(psiClass.getName());
List<Expression> baseClassParams = new LinkedList<Expression>();
List<Member> members = getMembers(psiClass);
// we try to find super() call and generate class declaration like that: class A(name: String, i
// : Int) : Base(name)
SuperVisitor visitor = new SuperVisitor();
psiClass.accept(visitor);
Collection<PsiExpressionList> resolvedSuperCallParameters =
visitor.getResolvedSuperCallParameters();
if (resolvedSuperCallParameters.size() == 1) {
baseClassParams.addAll(
expressionsToExpressionList(
resolvedSuperCallParameters.toArray(new PsiExpressionList[1])[0].getExpressions()));
}
// we create primary constructor from all non final fields and fields without initializers
if (!psiClass.isEnum()
&& !psiClass.isInterface()
&& psiClass.getConstructors().length > 1
&& getPrimaryConstructorForThisCase(psiClass) == null) {
List<Field> finalOrWithEmptyInitializer = getFinalOrWithEmptyInitializer(fields);
Map<String, String> initializers = new HashMap<String, String>();
for (Member m : members) {
// and modify secondaries
if (m.getKind() == INode.Kind.CONSTRUCTOR) {
Function f = (Function) m;
if (!((Constructor) f).isPrimary()) {
for (Field fo : finalOrWithEmptyInitializer) {
String init = getDefaultInitializer(fo);
initializers.put(fo.getIdentifier().toKotlin(), init);
}
List<Statement> newStatements = new LinkedList<Statement>();
for (Statement s : f.getBlock().getStatements()) {
boolean isRemoved = false;
if (s.getKind() == INode.Kind.ASSIGNMENT_EXPRESSION) {
AssignmentExpression assignmentExpression = (AssignmentExpression) s;
if (assignmentExpression.getLeft().getKind() == INode.Kind.CALL_CHAIN) {
for (Field fo : finalOrWithEmptyInitializer) {
String id = fo.getIdentifier().toKotlin();
if (((CallChainExpression) assignmentExpression.getLeft())
.getIdentifier()
.toKotlin()
.endsWith("." + id)) {
initializers.put(id, assignmentExpression.getRight().toKotlin());
isRemoved = true;
}
}
}
}
if (!isRemoved) {
newStatements.add(s);
}
}
newStatements.add(
0,
new DummyStringExpression(
"val __ = "
+ createPrimaryConstructorInvocation(
name.toKotlin(), finalOrWithEmptyInitializer, initializers)));
f.setBlock(new Block(newStatements));
}
}
}
members.add(
new Constructor(
Identifier.EMPTY_IDENTIFIER,
Collections.<String>emptySet(),
new ClassType(name),
Collections.<Element>emptyList(),
new ParameterList(createParametersFromFields(finalOrWithEmptyInitializer)),
new Block(createInitStatementsFromFields(finalOrWithEmptyInitializer)),
true));
}
if (psiClass.isInterface()) {
return new Trait(
this,
name,
modifiers,
typeParameters,
extendsTypes,
Collections.<Expression>emptyList(),
implementsTypes,
members);
}
if (psiClass.isEnum()) {
return new Enum(
this,
name,
modifiers,
typeParameters,
Collections.<Type>emptyList(),
Collections.<Expression>emptyList(),
implementsTypes,
members);
}
return new Class(
this,
name,
modifiers,
typeParameters,
extendsTypes,
baseClassParams,
implementsTypes,
members);
}
private PsiClass buildClass() {
final PsiManager manager = sourceClass.getManager();
final Project project = sourceClass.getProject();
final ExtractedClassBuilder extractedClassBuilder = new ExtractedClassBuilder();
extractedClassBuilder.setProject(myProject);
extractedClassBuilder.setClassName(newClassName);
extractedClassBuilder.setPackageName(newPackageName);
extractedClassBuilder.setOriginalClassName(sourceClass.getQualifiedName());
extractedClassBuilder.setRequiresBackPointer(requiresBackpointer);
extractedClassBuilder.setExtractAsEnum(enumConstants);
for (PsiField field : fields) {
extractedClassBuilder.addField(field);
}
for (PsiMethod method : methods) {
extractedClassBuilder.addMethod(method);
}
for (PsiClass innerClass : innerClasses) {
extractedClassBuilder.addInnerClass(
innerClass, innerClassesToMakePublic.contains(innerClass));
}
extractedClassBuilder.setTypeArguments(typeParams);
final List<PsiClass> interfaces = calculateInterfacesSupported();
extractedClassBuilder.setInterfaces(interfaces);
if (myGenerateAccessors) {
final NecessaryAccessorsVisitor visitor = checkNecessaryGettersSetters4ExtractedClass();
sourceClass.accept(visitor);
extractedClassBuilder.setFieldsNeedingGetters(visitor.getFieldsNeedingGetter());
extractedClassBuilder.setFieldsNeedingSetters(visitor.getFieldsNeedingSetter());
}
final String classString = extractedClassBuilder.buildBeanClass();
if (extractInnerClass) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiJavaFile newFile =
(PsiJavaFile)
factory.createFileFromText(
newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiClass psiClass = newFile.getClasses()[0];
if (!psiClass.isEnum()) {
final PsiModifierList modifierList = psiClass.getModifierList();
assert modifierList != null;
modifierList.setModifierProperty(PsiModifier.STATIC, true);
}
final PsiElement addedClass = sourceClass.add(psiClass);
return (PsiClass)
CodeStyleManager.getInstance(manager)
.reformat(
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedClass));
}
try {
final PsiFile containingFile = sourceClass.getContainingFile();
final PsiDirectory directory;
final PsiDirectory containingDirectory = containingFile.getContainingDirectory();
if (myMoveDestination != null) {
directory = myMoveDestination.getTargetDirectory(containingDirectory);
} else {
final Module module = ModuleUtil.findModuleForPsiElement(containingFile);
assert module != null;
directory =
PackageUtil.findOrCreateDirectoryForPackage(
module, newPackageName, containingDirectory, false, true);
}
if (directory != null) {
final PsiFileFactory factory = PsiFileFactory.getInstance(project);
final PsiFile newFile =
factory.createFileFromText(newClassName + ".java", JavaFileType.INSTANCE, classString);
final PsiElement addedFile = directory.add(newFile);
final CodeStyleManager codeStyleManager =
CodeStyleManager.getInstance(manager.getProject());
final PsiElement shortenedFile =
JavaCodeStyleManager.getInstance(project).shortenClassReferences(addedFile);
return ((PsiJavaFile) codeStyleManager.reformat(shortenedFile)).getClasses()[0];
} else {
return null;
}
} catch (IncorrectOperationException e) {
return null;
}
}
