public ClsJavaCodeReferenceElementImpl(PsiElement parent, String canonicalText) {
myParent = parent;
myCanonicalText = canonicalText;
final String[] classParametersText = PsiNameHelper.getClassParametersText(canonicalText);
int length = classParametersText.length;
myTypeParameters = length == 0 ? EMPTY_ARRAY : new ClsTypeElementImpl[length];
for (int i = 0; i < length; i++) {
String s = classParametersText[length - i - 1];
char variance = ClsTypeElementImpl.VARIANCE_NONE;
if (s.startsWith(EXTENDS_PREFIX)) {
variance = ClsTypeElementImpl.VARIANCE_EXTENDS;
s = s.substring(EXTENDS_PREFIX.length());
} else if (s.startsWith(SUPER_PREFIX)) {
variance = ClsTypeElementImpl.VARIANCE_SUPER;
s = s.substring(SUPER_PREFIX.length());
} else if (StringUtil.startsWithChar(s, '?')) {
variance = ClsTypeElementImpl.VARIANCE_INVARIANT;
s = s.substring(1);
}
myTypeParameters[i] = new ClsTypeElementImpl(this, s, variance);
}
myQualifiedName = PsiNameHelper.getQualifiedClassName(myCanonicalText, false);
}
public static void checkCreateClassOrInterface(@NotNull PsiDirectory directory, String name)
throws IncorrectOperationException {
PsiUtil.checkIsIdentifier(directory.getManager(), name);
String fileName = name + "." + StdFileTypes.JAVA.getDefaultExtension();
directory.checkCreateFile(fileName);
PsiNameHelper helper = JavaPsiFacade.getInstance(directory.getProject()).getNameHelper();
PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(directory);
String qualifiedName = aPackage == null ? null : aPackage.getQualifiedName();
if (!StringUtil.isEmpty(qualifiedName) && !helper.isQualifiedName(qualifiedName)) {
throw new IncorrectOperationException(
"Cannot create class in invalid package: '" + qualifiedName + "'");
}
}
@Nullable
private MoveDestination selectDestination() {
final String packageName = getTargetPackage().trim();
if (packageName.length() > 0
&& !PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(packageName)) {
Messages.showErrorDialog(
myProject,
RefactoringBundle.message("please.enter.a.valid.target.package.name"),
RefactoringBundle.message("move.title"));
return null;
}
RecentsManager.getInstance(myProject).registerRecentEntry(RECENTS_KEY, packageName);
PackageWrapper targetPackage = new PackageWrapper(myManager, packageName);
if (!targetPackage.exists()) {
final int ret =
Messages.showYesNoDialog(
myProject,
RefactoringBundle.message("package.does.not.exist", packageName),
RefactoringBundle.message("move.title"),
Messages.getQuestionIcon());
if (ret != Messages.YES) return null;
}
return ((DestinationFolderComboBox) myDestinationFolderCB)
.selectDirectory(targetPackage, mySuggestToMoveToAnotherRoot);
}
@NotNull
@Override
public PsiJavaCodeReferenceElement createReferenceElementByFQClassName(
@NotNull final String qName, @NotNull final GlobalSearchScope resolveScope) {
final String shortName = PsiNameHelper.getShortClassName(qName);
return new LightClassReference(myManager, shortName, qName, resolveScope);
}
public String getReferenceName() {
if (myPackageName != null) {
return PsiNameHelper.getShortClassName(myPackageName);
} else {
return myRefPackage.getName();
}
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
switch (columnIndex) {
case CHECKMARK_COLUMN:
{
getVariableData()[rowIndex].passAsParameter = ((Boolean) aValue).booleanValue();
fireTableRowsUpdated(rowIndex, rowIndex);
myTable.getSelectionModel().setSelectionInterval(rowIndex, rowIndex);
updateSignature();
break;
}
case PARAMETER_NAME_COLUMN:
{
VariableData data = getVariableData()[rowIndex];
String name = (String) aValue;
if (PsiNameHelper.getInstance(myProject).isIdentifier(name)) {
data.name = name;
}
updateSignature();
break;
}
case PARAMETER_TYPE_COLUMN:
{
VariableData data = getVariableData()[rowIndex];
data.type = (PsiType) aValue;
updateSignature();
break;
}
}
}
@Override
protected void canRun() throws ConfigurationException {
String name = getParameterName();
if (name == null || !PsiNameHelper.getInstance(myProject).isIdentifier(name)) {
throw new ConfigurationException(
"\'" + (name != null ? name : "") + "\' is invalid parameter name");
}
}
@NotNull
@Override
public PsiKeyword createKeyword(@NotNull final String text) throws IncorrectOperationException {
if (!PsiNameHelper.getInstance(myManager.getProject()).isKeyword(text)) {
throw new IncorrectOperationException("\"" + text + "\" is not a keyword.");
}
return new LightKeyword(myManager, text);
}
private boolean hasAcceptablePackage(@NotNull VirtualFile vFile) {
if (vFile.getFileType() == JavaClassFileType.INSTANCE) {
// See IDEADEV-5626
final VirtualFile root =
ProjectRootManager.getInstance(myManager.getProject())
.getFileIndex()
.getClassRootForFile(vFile);
VirtualFile parent = vFile.getParent();
final PsiNameHelper nameHelper = PsiNameHelper.getInstance(myManager.getProject());
while (parent != null && !Comparing.equal(parent, root)) {
if (!nameHelper.isIdentifier(parent.getName())) return false;
parent = parent.getParent();
}
}
return true;
}
@Override
public void indexStub(@NotNull GrReferenceListStub stub, @NotNull IndexSink sink) {
for (String name : stub.getBaseClasses()) {
if (name != null) {
sink.occurrence(GrDirectInheritorsIndex.KEY, PsiNameHelper.getShortClassName(name));
}
}
}
private static PsiClass findSingleImportByShortName(
@NotNull PsiJavaFile file, @NotNull String shortClassName) {
PsiClass[] refs = file.getSingleClassImports(true);
for (PsiClass ref : refs) {
String className = ref.getQualifiedName();
if (className != null && PsiNameHelper.getShortClassName(className).equals(shortClassName)) {
return ref;
}
}
for (PsiClass aClass : file.getClasses()) {
String className = aClass.getQualifiedName();
if (className != null && PsiNameHelper.getShortClassName(className).equals(shortClassName)) {
return aClass;
}
}
return null;
}
private String getText(boolean qualified, boolean annotated) {
PsiAnnotation[] annotations = getAnnotations();
if (!annotated || annotations.length == 0) return myName;
StringBuilder sb = new StringBuilder();
PsiNameHelper.appendAnnotations(sb, annotations, qualified);
sb.append(myName);
return sb.toString();
}
@NotNull
public static String getShortTypeText(@Nullable String text) {
if (text == null) {
return "";
}
int i = text.length();
while (i - 2 >= 0 && text.charAt(i - 2) == '[' && text.charAt(i - 1) == ']') {
i -= 2;
}
return PsiNameHelper.getShortClassName(text.substring(0, i)) + text.substring(i);
}
@Override
public boolean processDeclarations(
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
PsiElement lastParent,
@NotNull PsiElement place) {
GlobalSearchScope scope = place.getResolveScope();
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final Condition<String> nameCondition = processor.getHint(JavaCompletionHints.NAME_FILTER);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
final String shortName = nameHint.getName(state);
final PsiClass[] classes = findClassByShortName(shortName, scope);
if (!processClasses(processor, state, classes, Conditions.<String>alwaysTrue()))
return false;
} else {
PsiClass[] classes = getClasses(scope);
if (!processClasses(
processor,
state,
classes,
nameCondition != null ? nameCondition : Conditions.<String>alwaysTrue())) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.PACKAGE)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
PsiPackage aPackage = findSubPackageByName(nameHint.getName(state));
if (aPackage != null) {
if (!processor.execute(aPackage, state)) return false;
}
} else {
PsiPackage[] packs = getSubPackages(scope);
for (PsiPackage pack : packs) {
final String packageName = pack.getName();
if (packageName == null) continue;
if (!PsiNameHelper.getInstance(myManager.getProject())
.isIdentifier(packageName, PsiUtil.getLanguageLevel(this))) {
continue;
}
if (!processor.execute(pack, state)) {
return false;
}
}
}
}
return true;
}
private String calculateDelegateFieldName() {
final Project project = sourceClass.getProject();
final CodeStyleSettingsManager settingsManager = CodeStyleSettingsManager.getInstance(project);
final CodeStyleSettings settings = settingsManager.getCurrentSettings();
final String baseName =
settings.FIELD_NAME_PREFIX.length() == 0
? StringUtil.decapitalize(newClassName)
: newClassName;
String name = settings.FIELD_NAME_PREFIX + baseName + settings.FIELD_NAME_SUFFIX;
if (!existsFieldWithName(name) && !PsiNameHelper.getInstance(project).isKeyword(name)) {
return name;
}
int counter = 1;
while (true) {
name = settings.FIELD_NAME_PREFIX + baseName + counter + settings.FIELD_NAME_SUFFIX;
if (!existsFieldWithName(name) && !PsiNameHelper.getInstance(project).isKeyword(name)) {
return name;
}
counter++;
}
}
@Override
protected void canRun() throws ConfigurationException {
if (isMoveToPackage()) {
String name = getTargetPackage().trim();
if (name.length() != 0
&& !PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(name)) {
throw new ConfigurationException("\'" + name + "\' is invalid destination package name");
}
} else {
if (findTargetClass() == null)
throw new ConfigurationException("Destination class not found");
final String validationError = verifyInnerClassDestination();
if (validationError != null) throw new ConfigurationException(validationError);
}
}
public void _commit(boolean finishChosen) throws CommitStepException {
// Stop editing if any
final TableCellEditor cellEditor = myTable.getCellEditor();
if (cellEditor != null) {
cellEditor.stopCellEditing();
}
// Check that all included fields are bound to valid bean properties
final PsiNameHelper nameHelper = JavaPsiFacade.getInstance(myData.myProject).getNameHelper();
for (int i = 0; i < myData.myBindings.length; i++) {
final FormProperty2BeanProperty binding = myData.myBindings[i];
if (binding.myBeanProperty == null) {
continue;
}
if (!nameHelper.isIdentifier(binding.myBeanProperty.myName)) {
throw new CommitStepException(
UIDesignerBundle.message(
"error.X.is.not.a.valid.property.name", binding.myBeanProperty.myName));
}
}
myData.myGenerateIsModified = myChkIsModified.isSelected();
}
@NotNull
@Override
public PsiImportStatement createImportStatementOnDemand(@NotNull final String packageName)
throws IncorrectOperationException {
if (packageName.isEmpty()) {
throw new IncorrectOperationException("Cannot create import statement for default package.");
}
if (!PsiNameHelper.getInstance(myManager.getProject()).isQualifiedName(packageName)) {
throw new IncorrectOperationException("Incorrect package name: \"" + packageName + "\".");
}
final PsiJavaFile aFile = createDummyJavaFile("import " + packageName + ".*;");
final PsiImportStatementBase statement = extractImport(aFile, false);
return (PsiImportStatement)
CodeStyleManager.getInstance(myManager.getProject()).reformat(statement);
}
public static PsiType buildTypeFromTypeString(
@NotNull final String typeName,
@NotNull final PsiElement context,
@NotNull final PsiFile psiFile) {
PsiType resultType;
final PsiManager psiManager = psiFile.getManager();
if (typeName.indexOf('<') != -1 || typeName.indexOf('[') != -1 || typeName.indexOf('.') == -1) {
try {
return JavaPsiFacade.getInstance(psiManager.getProject())
.getElementFactory()
.createTypeFromText(typeName, context);
} catch (Exception ignored) {
} // invalid syntax will produce unresolved class type
}
PsiClass aClass =
JavaPsiFacade.getInstance(psiManager.getProject())
.findClass(typeName, context.getResolveScope());
if (aClass == null) {
final LightClassReference ref =
new LightClassReference(
psiManager,
PsiNameHelper.getShortClassName(typeName),
typeName,
PsiSubstitutor.EMPTY,
psiFile);
resultType = new PsiClassReferenceType(ref, null);
} else {
PsiElementFactory factory =
JavaPsiFacade.getInstance(psiManager.getProject()).getElementFactory();
PsiSubstitutor substitutor = factory.createRawSubstitutor(aClass);
resultType = factory.createType(aClass, substitutor);
}
return resultType;
}
/**
* Adds import if it is needed.
*
* @return false when the FQ-name have to be used in code (e.g. when conflicting imports already
* exist)
*/
public boolean addImport(@NotNull PsiJavaFile file, @NotNull PsiClass refClass) {
final JavaPsiFacade facade = JavaPsiFacade.getInstance(file.getProject());
PsiElementFactory factory = facade.getElementFactory();
PsiResolveHelper helper = facade.getResolveHelper();
String className = refClass.getQualifiedName();
if (className == null) return true;
String packageName = getPackageOrClassName(className);
String shortName = PsiNameHelper.getShortClassName(className);
PsiClass conflictSingleRef = findSingleImportByShortName(file, shortName);
if (conflictSingleRef != null) {
return className.equals(conflictSingleRef.getQualifiedName());
}
PsiClass curRefClass = helper.resolveReferencedClass(shortName, file);
if (file.getManager().areElementsEquivalent(refClass, curRefClass)) {
return true;
}
boolean useOnDemand = true;
if (packageName.length() == 0) {
useOnDemand = false;
}
PsiElement conflictPackageRef = findImportOnDemand(file, packageName);
if (conflictPackageRef != null) {
useOnDemand = false;
}
List<PsiElement> classesToReimport = new ArrayList<PsiElement>();
List<PsiJavaCodeReferenceElement> importRefs = getImportsFromPackage(file, packageName);
if (useOnDemand) {
if (mySettings.USE_SINGLE_CLASS_IMPORTS
&& importRefs.size() + 1 < mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND
&& !mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.contains(packageName)) {
useOnDemand = false;
}
// name of class we try to import is the same as of the class defined in this file
if (curRefClass != null) {
useOnDemand = true;
}
// check conflicts
if (useOnDemand) {
PsiElement[] onDemandRefs = file.getOnDemandImports(false, true);
if (onDemandRefs.length > 0) {
PsiPackage aPackage = facade.findPackage(packageName);
if (aPackage != null) {
PsiDirectory[] dirs = aPackage.getDirectories();
for (PsiDirectory dir : dirs) {
PsiFile[] files = dir.getFiles(); // do not iterate classes - too slow when not loaded
for (PsiFile aFile : files) {
if (aFile instanceof PsiJavaFile) {
String name = aFile.getVirtualFile().getNameWithoutExtension();
for (PsiElement ref : onDemandRefs) {
String refName =
ref instanceof PsiClass
? ((PsiClass) ref).getQualifiedName()
: ((PsiPackage) ref).getQualifiedName();
String conflictClassName = refName + "." + name;
GlobalSearchScope resolveScope = file.getResolveScope();
PsiClass conflictClass = facade.findClass(conflictClassName, resolveScope);
if (conflictClass != null && helper.isAccessible(conflictClass, file, null)) {
String conflictClassName2 = aPackage.getQualifiedName() + "." + name;
PsiClass conflictClass2 = facade.findClass(conflictClassName2, resolveScope);
if (conflictClass2 != null
&& helper.isAccessible(conflictClass2, file, null)) {
if (ReferencesSearch.search(
conflictClass, new LocalSearchScope(file), false)
.findFirst()
!= null) {
classesToReimport.add(conflictClass);
}
}
}
}
}
}
}
}
}
}
}
try {
PsiImportList importList = file.getImportList();
PsiImportStatement statement;
if (useOnDemand) {
statement = factory.createImportStatementOnDemand(packageName);
} else {
statement = factory.createImportStatement(refClass);
}
importList.add(statement);
if (useOnDemand) {
for (PsiJavaCodeReferenceElement ref : importRefs) {
LOG.assertTrue(ref.getParent() instanceof PsiImportStatement);
if (!ref.isValid()) continue; // todo[dsl] Q?
classesToReimport.add(ref.resolve());
PsiImportStatement importStatement = (PsiImportStatement) ref.getParent();
importStatement.delete();
}
}
for (PsiElement aClassesToReimport : classesToReimport) {
PsiClass aClass = (PsiClass) aClassesToReimport;
if (aClass != null) {
addImport(file, aClass);
}
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
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;
}
@Override
public String getReferenceName() {
return PsiNameHelper.getShortClassName(myCanonicalText);
}
private boolean isIdentifier(String name) {
return PsiNameHelper.getInstance(myProject).isIdentifier(name, LanguageLevel.HIGHEST);
}
@Override
public String getText() {
return PsiNameHelper.getPresentableText(this);
}
private boolean isIdentifier(@NotNull String name) {
return PsiNameHelper.getInstance(myManager.getProject()).isIdentifier(name);
}
private void buildText(
@NotNull PsiClass aClass,
@NotNull PsiSubstitutor substitutor,
@NotNull StringBuilder buffer,
@NotNull TextType textType,
boolean annotated) {
if (aClass instanceof PsiAnonymousClass) {
ClassResolveResult baseResolveResult =
((PsiAnonymousClass) aClass).getBaseClassType().resolveGenerics();
PsiClass baseClass = baseResolveResult.getElement();
if (baseClass != null) {
buildText(baseClass, baseResolveResult.getSubstitutor(), buffer, textType, false);
}
return;
}
boolean qualified = textType != TextType.PRESENTABLE;
PsiClass enclosingClass = null;
if (!aClass.hasModifierProperty(PsiModifier.STATIC)) {
PsiElement parent = aClass.getParent();
if (parent instanceof PsiClass && !(parent instanceof PsiAnonymousClass)) {
enclosingClass = (PsiClass) parent;
}
}
if (enclosingClass != null) {
buildText(enclosingClass, substitutor, buffer, textType, false);
buffer.append('.');
} else if (qualified) {
String fqn = aClass.getQualifiedName();
if (fqn != null) {
String prefix = StringUtil.getPackageName(fqn);
if (!StringUtil.isEmpty(prefix)) {
buffer.append(prefix);
buffer.append('.');
}
}
}
if (annotated) {
PsiNameHelper.appendAnnotations(buffer, getAnnotations(), qualified);
}
buffer.append(aClass.getName());
PsiTypeParameter[] typeParameters = aClass.getTypeParameters();
if (typeParameters.length > 0) {
int pos = buffer.length();
buffer.append('<');
for (int i = 0; i < typeParameters.length; i++) {
PsiTypeParameter typeParameter = typeParameters[i];
PsiUtilCore.ensureValid(typeParameter);
if (i > 0) {
buffer.append(',');
if (textType == TextType.PRESENTABLE) buffer.append(' ');
}
PsiType substitutionResult = substitutor.substitute(typeParameter);
if (substitutionResult == null) {
buffer.setLength(pos);
pos = -1;
break;
}
PsiUtil.ensureValidType(substitutionResult);
if (textType == TextType.PRESENTABLE) {
buffer.append(substitutionResult.getPresentableText());
} else if (textType == TextType.CANONICAL) {
buffer.append(substitutionResult.getCanonicalText(annotated));
} else {
buffer.append(substitutionResult.getInternalCanonicalText());
}
}
if (pos >= 0) {
buffer.append('>');
}
}
}
@Override
public void visit(
int version,
int access,
String name,
String signature,
String superName,
String[] interfaces) {
String fqn = getClassName(name);
String shortName = myShortName != null ? myShortName : PsiNameHelper.getShortClassName(fqn);
int flags = myAccess == 0 ? access : myAccess;
boolean isDeprecated = (flags & Opcodes.ACC_DEPRECATED) != 0;
boolean isInterface = (flags & Opcodes.ACC_INTERFACE) != 0;
boolean isEnum = (flags & Opcodes.ACC_ENUM) != 0;
boolean isAnnotationType = (flags & Opcodes.ACC_ANNOTATION) != 0;
byte stubFlags =
PsiClassStubImpl.packFlags(
isDeprecated, isInterface, isEnum, false, false, isAnnotationType, false, false);
myResult =
new PsiClassStubImpl(JavaStubElementTypes.CLASS, myParent, fqn, shortName, null, stubFlags);
LanguageLevel languageLevel = convertFromVersion(version);
((PsiClassStubImpl) myResult).setLanguageLevel(languageLevel);
myModList = new PsiModifierListStubImpl(myResult, packClassFlags(flags));
CharacterIterator signatureIterator =
signature != null ? new StringCharacterIterator(signature) : null;
if (signatureIterator != null) {
try {
SignatureParsing.parseTypeParametersDeclaration(signatureIterator, myResult);
} catch (ClsFormatException e) {
signatureIterator = null;
}
} else {
new PsiTypeParameterListStubImpl(myResult);
}
String convertedSuper;
List<String> convertedInterfaces = new ArrayList<String>();
if (signatureIterator == null) {
convertedSuper = parseClassDescription(superName, interfaces, convertedInterfaces);
} else {
try {
convertedSuper = parseClassSignature(signatureIterator, convertedInterfaces);
} catch (ClsFormatException e) {
new PsiTypeParameterListStubImpl(myResult);
convertedSuper = parseClassDescription(superName, interfaces, convertedInterfaces);
}
}
if (isInterface) {
if (isAnnotationType) {
convertedInterfaces.remove(JAVA_LANG_ANNOTATION_ANNOTATION);
}
newReferenceList(
JavaStubElementTypes.EXTENDS_LIST,
myResult,
ArrayUtil.toStringArray(convertedInterfaces));
newReferenceList(JavaStubElementTypes.IMPLEMENTS_LIST, myResult);
} else {
if (convertedSuper == null
|| JAVA_LANG_OBJECT.equals(convertedSuper)
|| isEnum
&& (JAVA_LANG_ENUM.equals(convertedSuper)
|| (JAVA_LANG_ENUM + "<" + fqn + ">").equals(convertedSuper))) {
newReferenceList(JavaStubElementTypes.EXTENDS_LIST, myResult);
} else {
newReferenceList(JavaStubElementTypes.EXTENDS_LIST, myResult, convertedSuper);
}
newReferenceList(
JavaStubElementTypes.IMPLEMENTS_LIST,
myResult,
ArrayUtil.toStringArray(convertedInterfaces));
}
}
private void updateOkStatus() {
String text = getEnteredName();
setOKActionEnabled(PsiNameHelper.getInstance(myProject).isIdentifier(text));
}