@Nullable
public static String getEnumConstantName(@NotNull ObjectReference objRef, ClassType classType) {
do {
if (!classType.isPrepared()) {
return null;
}
classType = classType.superclass();
if (classType == null) {
return null;
}
} while (!(CommonClassNames.JAVA_LANG_ENUM.equals(classType.name())));
//noinspection HardCodedStringLiteral
final Field field = classType.fieldByName("name");
if (field == null) {
return null;
}
final Value value = objRef.getValue(field);
if (!(value instanceof StringReference)) {
return null;
}
return ((StringReference) value).value();
}
public static PsiMethod generateConstructorPrototype(
PsiClass aClass, PsiMethod baseConstructor, boolean copyJavaDoc, PsiField[] fields)
throws IncorrectOperationException {
PsiManager manager = aClass.getManager();
JVMElementFactory factory =
JVMElementFactories.requireFactory(aClass.getLanguage(), aClass.getProject());
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(manager.getProject());
PsiMethod constructor = factory.createConstructor(aClass.getName(), aClass);
String modifier = PsiUtil.getMaximumModifierForMember(aClass, false);
if (modifier != null) {
PsiUtil.setModifierProperty(constructor, modifier, true);
}
if (baseConstructor != null) {
PsiJavaCodeReferenceElement[] throwRefs =
baseConstructor.getThrowsList().getReferenceElements();
for (PsiJavaCodeReferenceElement ref : throwRefs) {
constructor.getThrowsList().add(ref);
}
if (copyJavaDoc) {
final PsiDocComment docComment =
((PsiMethod) baseConstructor.getNavigationElement()).getDocComment();
if (docComment != null) {
constructor.addAfter(docComment, null);
}
}
}
boolean isNotEnum = false;
if (baseConstructor != null) {
PsiClass superClass = aClass.getSuperClass();
LOG.assertTrue(superClass != null);
if (!CommonClassNames.JAVA_LANG_ENUM.equals(superClass.getQualifiedName())) {
isNotEnum = true;
if (baseConstructor instanceof PsiCompiledElement) { // to get some parameter names
PsiClass dummyClass =
JVMElementFactories.requireFactory(
baseConstructor.getLanguage(), baseConstructor.getProject())
.createClass("Dummy");
baseConstructor = (PsiMethod) dummyClass.add(baseConstructor);
}
PsiParameter[] params = baseConstructor.getParameterList().getParameters();
for (PsiParameter param : params) {
PsiParameter newParam = factory.createParameter(param.getName(), param.getType(), aClass);
GenerateMembersUtil.copyOrReplaceModifierList(param, newParam);
constructor.getParameterList().add(newParam);
}
}
}
JavaCodeStyleManager javaStyle = JavaCodeStyleManager.getInstance(aClass.getProject());
final PsiMethod dummyConstructor = factory.createConstructor(aClass.getName());
dummyConstructor.getParameterList().replace(constructor.getParameterList().copy());
List<PsiParameter> fieldParams = new ArrayList<PsiParameter>();
for (PsiField field : fields) {
String fieldName = field.getName();
String name = javaStyle.variableNameToPropertyName(fieldName, VariableKind.FIELD);
String parmName = javaStyle.propertyNameToVariableName(name, VariableKind.PARAMETER);
parmName = javaStyle.suggestUniqueVariableName(parmName, dummyConstructor, true);
PsiParameter parm = factory.createParameter(parmName, field.getType(), aClass);
final NullableNotNullManager nullableManager =
NullableNotNullManager.getInstance(field.getProject());
final String notNull = nullableManager.getNotNull(field);
if (notNull != null) {
parm.getModifierList()
.addAfter(factory.createAnnotationFromText("@" + notNull, field), null);
}
constructor.getParameterList().add(parm);
dummyConstructor.getParameterList().add(parm.copy());
fieldParams.add(parm);
}
ConstructorBodyGenerator generator =
ConstructorBodyGenerator.INSTANCE.forLanguage(aClass.getLanguage());
if (generator != null) {
@NonNls StringBuilder buffer = new StringBuilder();
generator.start(buffer, constructor.getName(), PsiParameter.EMPTY_ARRAY);
if (isNotEnum) {
generator.generateSuperCallIfNeeded(
buffer, baseConstructor.getParameterList().getParameters());
}
generator.generateFieldInitialization(
buffer, fields, fieldParams.toArray(new PsiParameter[fieldParams.size()]));
generator.finish(buffer);
PsiMethod stub = factory.createMethodFromText(buffer.toString(), aClass);
constructor.getBody().replace(stub.getBody());
}
constructor = (PsiMethod) codeStyleManager.reformat(constructor);
return constructor;
}