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); } } }
private static PsiSubstitutor obtainFinalSubstitutor( PsiClass superClass, PsiSubstitutor superSubstitutor, PsiSubstitutor derivedSubstitutor, boolean inRawContext) { if (inRawContext) { Set<PsiTypeParameter> typeParams = superSubstitutor.getSubstitutionMap().keySet(); PsiElementFactory factory = JavaPsiFacade.getElementFactory(superClass.getProject()); superSubstitutor = factory.createRawSubstitutor( derivedSubstitutor, typeParams.toArray(new PsiTypeParameter[typeParams.size()])); } Map<PsiTypeParameter, PsiType> map = null; for (PsiTypeParameter typeParameter : PsiUtil.typeParametersIterable(superClass)) { PsiType type = superSubstitutor.substitute(typeParameter); final PsiType t = derivedSubstitutor.substitute(type); if (map == null) { map = new THashMap<PsiTypeParameter, PsiType>(); } map.put(typeParameter, t); } return map == null ? PsiSubstitutor.EMPTY : JavaPsiFacade.getInstance(superClass.getProject()) .getElementFactory() .createSubstitutor(map); }
@NotNull private static PsiClass[] getSupersInner(@NotNull PsiClass psiClass) { PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes(); PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes(); if (psiClass.isInterface()) { return resolveClassReferenceList( extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), true); } if (psiClass instanceof PsiAnonymousClass) { PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass) psiClass; PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType(); PsiClass baseClass = baseClassReference.resolve(); if (baseClass != null) { if (baseClass.isInterface()) { PsiClass objectClass = JavaPsiFacade.getInstance(psiClass.getProject()) .findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope()); return objectClass != null ? new PsiClass[] {objectClass, baseClass} : new PsiClass[] {baseClass}; } return new PsiClass[] {baseClass}; } PsiClass objectClass = JavaPsiFacade.getInstance(psiClass.getProject()) .findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope()); return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY; } if (psiClass instanceof PsiTypeParameter) { if (extendsListTypes.length == 0) { final PsiClass objectClass = JavaPsiFacade.getInstance(psiClass.getProject()) .findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope()); return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY; } return resolveClassReferenceList( extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false); } PsiClass[] interfaces = resolveClassReferenceList( implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false); PsiClass superClass = getSuperClass(psiClass); if (superClass == null) return interfaces; PsiClass[] types = new PsiClass[interfaces.length + 1]; types[0] = superClass; System.arraycopy(interfaces, 0, types, 1, interfaces.length); return types; }
@Before public void setUp() { given(psiClass.isEnum()).willReturn(false); given(psiClass.isInterface()).willReturn(false); given(psiClass.isAnnotationType()).willReturn(false); given(psiClass.getProject()).willReturn(project); given(psiClass.getName()).willReturn(CLASS_NAME); given(builderClass.getName()).willReturn(BUILDER_NAME); given(builderClass.getProject()).willReturn(project); }
@NotNull @Override public List<LightRef> getHierarchyRestrictedToLibraryScope( @NotNull LightRef baseRef, @NotNull PsiElement basePsi, @NotNull ByteArrayEnumerator names, @NotNull GlobalSearchScope libraryScope) { final PsiClass baseClass = ObjectUtils.notNull( basePsi instanceof PsiClass ? (PsiClass) basePsi : ReadAction.compute(() -> (PsiMember) basePsi).getContainingClass()); final List<LightRef> overridden = new ArrayList<>(); Processor<PsiClass> processor = c -> { if (c.hasModifierProperty(PsiModifier.PRIVATE)) return true; String qName = ReadAction.compute(() -> c.getQualifiedName()); if (qName == null) return true; overridden.add(baseRef.override(id(qName, names))); return true; }; ClassInheritorsSearch.search( baseClass, LibraryScopeCache.getInstance(baseClass.getProject()).getLibrariesOnlyScope(), true) .forEach(processor); return overridden; }
private static void putInMap( PsiClass aClass, Map<MethodSignature, HierarchicalMethodSignature> result, Map<MethodSignature, HierarchicalMethodSignatureImpl> map, HierarchicalMethodSignature hierarchicalMethodSignature, MethodSignature signature) { if (!PsiUtil.isAccessible( aClass.getProject(), hierarchicalMethodSignature.getMethod(), aClass, aClass)) return; HierarchicalMethodSignatureImpl existing = map.get(signature); if (existing == null) { HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature); LOG.assertTrue(copy.getMethod().isValid()); map.put(signature, copy); } else if (isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing) && isSuperMethod(aClass, hierarchicalMethodSignature, existing)) { HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature); mergeSupers(newSuper, existing); LOG.assertTrue(newSuper.getMethod().isValid()); map.put(signature, newSuper); } else if (isSuperMethod(aClass, existing, hierarchicalMethodSignature)) { mergeSupers(existing, hierarchicalMethodSignature); } // just drop an invalid method declaration there - to highlight accordingly else if (!result.containsKey(signature)) { LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid()); result.put(signature, hierarchicalMethodSignature); } }
@Override public PsiType visitClassType(PsiClassType classType) { final PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics(); final PsiClass aClass = resolveResult.getElement(); if (aClass == null) return classType; PsiUtilCore.ensureValid(aClass); if (aClass instanceof PsiTypeParameter) { final PsiTypeParameter typeParameter = (PsiTypeParameter) aClass; if (containsInMap(typeParameter)) { PsiType result = substituteTypeParameter(typeParameter); if (result != null) { PsiUtil.ensureValidType(result); } return result; } return classType; } final Map<PsiTypeParameter, PsiType> hashMap = new HashMap<PsiTypeParameter, PsiType>(2); if (!processClass(aClass, resolveResult.getSubstitutor(), hashMap)) { return null; } PsiClassType result = JavaPsiFacade.getElementFactory(aClass.getProject()) .createType(aClass, createSubstitutor(hashMap), classType.getLanguageLevel()); PsiUtil.ensureValidType(result); return result; }
public static GdkMethodHolder getHolderForClass( final PsiClass categoryClass, final boolean isStatic, final GlobalSearchScope scope) { final Project project = categoryClass.getProject(); Key<CachedValue<GdkMethodHolder>> key = isStatic ? CACHED_STATIC : CACHED_NON_STATIC; return CachedValuesManager.getManager(project) .getCachedValue( categoryClass, key, new CachedValueProvider<GdkMethodHolder>() { @Override public Result<GdkMethodHolder> compute() { GdkMethodHolder result = new GdkMethodHolder(categoryClass, isStatic, scope); final ProjectRootManager rootManager = ProjectRootManager.getInstance(project); final VirtualFile vfile = categoryClass.getContainingFile().getVirtualFile(); if (vfile != null && (rootManager.getFileIndex().isInLibraryClasses(vfile) || rootManager.getFileIndex().isInLibrarySource(vfile))) { return Result.create(result, rootManager); } return Result.create( result, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT, rootManager); } }, false); }
public static boolean inheritsITestListener(@NotNull PsiClass psiClass) { final Project project = psiClass.getProject(); final PsiClass aListenerClass = JavaPsiFacade.getInstance(project) .findClass(ITestNGListener.class.getName(), GlobalSearchScope.allScope(project)); return aListenerClass != null && psiClass.isInheritor(aListenerClass, true); }
@Nullable private PsiClass mapClass(@NotNull PsiClass psiClass) { String qualifiedName = psiClass.getQualifiedName(); if (qualifiedName == null) { return psiClass; } PsiFile file = psiClass.getContainingFile(); if (file == null || !file.getViewProvider().isPhysical()) { return psiClass; } final VirtualFile vFile = file.getVirtualFile(); if (vFile == null) { return psiClass; } final FileIndexFacade index = FileIndexFacade.getInstance(file.getProject()); if (!index.isInSource(vFile) && !index.isInLibrarySource(vFile) && !index.isInLibraryClasses(vFile)) { return psiClass; } return JavaPsiFacade.getInstance(psiClass.getProject()) .findClass(qualifiedName, myResolveScope); }
@NotNull @Override public PsiClassType rawType() { PsiClass psiClass = resolve(); PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject()); return factory.createType(psiClass, factory.createRawSubstitutor(psiClass)); }
@Nullable public static PsiQualifiedReference getClassReferenceToShorten( @NotNull final PsiClass refClass, final boolean addImports, @NotNull final PsiQualifiedReference reference) { PsiClass parentClass = refClass.getContainingClass(); if (parentClass != null) { JavaPsiFacade facade = JavaPsiFacade.getInstance(parentClass.getProject()); final PsiResolveHelper resolveHelper = facade.getResolveHelper(); if (resolveHelper.isAccessible(refClass, reference, null) && isSafeToShortenReference(reference.getReferenceName(), reference, refClass)) { return reference; } if (!CodeStyleSettingsManager.getSettings(reference.getProject()) .INSERT_INNER_CLASS_IMPORTS) { final PsiElement qualifier = reference.getQualifier(); if (qualifier instanceof PsiQualifiedReference) { return getClassReferenceToShorten( parentClass, addImports, (PsiQualifiedReference) qualifier); } return null; } } if (addImports && !((PsiImportHolder) reference.getContainingFile()).importClass(refClass)) return null; if (!isSafeToShortenReference(reference, refClass)) return null; return reference; }
@Override protected PsiMethod findOrCreateSetUpMethod(PsiClass clazz) throws IncorrectOperationException { LOG.assertTrue(clazz.getLanguage() == GroovyFileType.GROOVY_LANGUAGE); final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(clazz.getProject()); final PsiMethod patternMethod = createSetUpPatternMethod(factory); final PsiClass baseClass = clazz.getSuperClass(); if (baseClass != null) { final PsiMethod baseMethod = baseClass.findMethodBySignature(patternMethod, false); if (baseMethod != null && baseMethod.hasModifierProperty(PsiModifier.PUBLIC)) { PsiUtil.setModifierProperty(patternMethod, PsiModifier.PROTECTED, false); PsiUtil.setModifierProperty(patternMethod, PsiModifier.PUBLIC, true); } } PsiMethod inClass = clazz.findMethodBySignature(patternMethod, false); if (inClass == null) { PsiMethod testMethod = JUnitUtil.findFirstTestMethod(clazz); if (testMethod != null) { return (PsiMethod) clazz.addBefore(patternMethod, testMethod); } return (PsiMethod) clazz.add(patternMethod); } else if (inClass.getBody() == null) { return (PsiMethod) inClass.replace(patternMethod); } return inClass; }
/* Guesswork */ @Nullable private static PsiSubstitutor getInheritorSubstitutorForNewExpression( final PsiClass baseClass, final PsiClass inheritor, final PsiSubstitutor baseSubstitutor, final PsiElement context) { final Project project = baseClass.getProject(); JavaPsiFacade facade = JavaPsiFacade.getInstance(project); final PsiResolveHelper resolveHelper = facade.getResolveHelper(); PsiSubstitutor superSubstitutor = TypeConversionUtil.getClassSubstitutor(baseClass, inheritor, PsiSubstitutor.EMPTY); if (superSubstitutor == null) return null; PsiSubstitutor inheritorSubstitutor = PsiSubstitutor.EMPTY; for (PsiTypeParameter inheritorParameter : PsiUtil.typeParametersIterable(inheritor)) { for (PsiTypeParameter baseParameter : PsiUtil.typeParametersIterable(baseClass)) { final PsiType substituted = superSubstitutor.substitute(baseParameter); PsiType arg = baseSubstitutor.substitute(baseParameter); if (arg instanceof PsiWildcardType) arg = ((PsiWildcardType) arg).getBound(); PsiType substitution = resolveHelper.getSubstitutionForTypeParameter( inheritorParameter, substituted, arg, true, PsiUtil.getLanguageLevel(context)); if (PsiType.NULL.equals(substitution)) continue; if (substitution == null) { return facade.getElementFactory().createRawSubstitutor(inheritor); } inheritorSubstitutor = inheritorSubstitutor.put(inheritorParameter, substitution); break; } } return inheritorSubstitutor; }
public String calcGenerics(@NotNull PsiElement context, InsertionContext insertionContext) { if (insertionContext.getCompletionChar() == '<') { return ""; } assert context.isValid(); if (myDiamond) { return "<>"; } if (getObject() instanceof PsiClass) { PsiClass psiClass = (PsiClass) getObject(); PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(psiClass.getProject()).getResolveHelper(); PsiSubstitutor substitutor = getSubstitutor(); StringBuilder builder = new StringBuilder(); for (PsiTypeParameter parameter : psiClass.getTypeParameters()) { PsiType substitute = substitutor.substitute(parameter); if (substitute == null || (PsiUtil.resolveClassInType(substitute) == parameter && resolveHelper.resolveReferencedClass(parameter.getName(), context) != CompletionUtil.getOriginalOrSelf(parameter))) { return ""; } if (builder.length() > 0) { builder.append(", "); } builder.append(substitute.getCanonicalText()); } if (builder.length() > 0) { return "<" + builder + ">"; } } return ""; }
public ClassUsageGroup(@NotNull PsiClass aClass) { myQName = aClass.getQualifiedName(); myText = createText(aClass); myClassPointer = SmartPointerManager.getInstance(aClass.getProject()).createSmartPsiElementPointer(aClass); myIcon = aClass.getIcon(Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS); }
public static void register( final HighlightInfo highlightInfo, PsiExpression expression, final PsiType lType) { expression = PsiUtil.deparenthesizeExpression(expression); if (!(expression instanceof PsiNewExpression)) return; final PsiType rType = expression.getType(); PsiType newType = lType; if (rType instanceof PsiClassType && newType instanceof PsiClassType) { final PsiClassType.ClassResolveResult rResolveResult = ((PsiClassType) rType).resolveGenerics(); final PsiClass rClass = rResolveResult.getElement(); if (rClass != null) { final PsiClassType.ClassResolveResult lResolveResult = ((PsiClassType) newType).resolveGenerics(); final PsiClass lClass = lResolveResult.getElement(); if (lClass != null) { PsiSubstitutor substitutor = getInheritorSubstitutorForNewExpression( lClass, rClass, lResolveResult.getSubstitutor(), expression); if (substitutor != null) { newType = JavaPsiFacade.getInstance(lClass.getProject()) .getElementFactory() .createType(rClass, substitutor); } } } } PsiNewExpression newExpression = (PsiNewExpression) expression; QuickFixAction.registerQuickFixAction( highlightInfo, new ChangeNewOperatorTypeFix(newType, newExpression)); }
public static boolean isProduction(PsiClass aClass) { final PsiFile file = PsiTreeUtil.getParentOfType(aClass, PsiFile.class); if (file == null) { return false; } final VirtualFile virtualFile = file.getVirtualFile(); return isProduction(virtualFile, aClass.getProject()); }
public CodeWriter( PsiFile psiFile, PsiClass clazz, List<ViewPart> viewPartList, boolean isViewHolder, boolean isAddRootView, String rootViewStr) { super(clazz.getProject(), ""); this.psiFile = psiFile; mProject = clazz.getProject(); mClass = clazz; mFactory = JavaPsiFacade.getElementFactory(mProject); this.viewPartList = viewPartList; this.isAddRootView = isAddRootView; this.isViewHolder = isViewHolder; this.rootViewStr = rootViewStr; }
public void generate(final PsiClass psiClass, final List<PsiField> fields) { new WriteCommandAction.Simple(psiClass.getProject(), psiClass.getContainingFile()) { @Override protected void run() throws Throwable { generateToString(psiClass, fields); } }.execute(); }
private static PsiType createType(PsiClass cls, PsiSubstitutor currentSubstitutor, int arrayDim) { final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(cls.getProject()).getElementFactory(); PsiType newType = elementFactory.createType(cls, currentSubstitutor); for (int i = 0; i < arrayDim; i++) { newType = newType.createArrayType(); } return newType; }
public GrPullUpHelper( PsiClass aClass, PsiClass superClass, GrMemberInfo[] infos, DocCommentPolicy policy) { super(aClass.getProject()); mySourceClass = aClass; myTargetSuperClass = (GrTypeDefinition) superClass; myMembersToMove = infos; myDocCommentPolicy = policy; }
private static PsiMethod createMethod(final String methodText, final PsiClass implClass) { try { return JavaPsiFacade.getInstance(implClass.getProject()) .getElementFactory() .createMethodFromText(methodText, implClass); } catch (IncorrectOperationException e) { LOG.error(e); return null; } }
public LayoutCreator( PsiFile file, PsiClass clazz, String command, ArrayList<Element> elements, String layoutFileName, String fieldNamePrefix, boolean createHolder) { super(clazz.getProject(), command); mFile = file; mProject = clazz.getProject(); mClass = clazz; mElements = elements; mFactory = JavaPsiFacade.getElementFactory(mProject); mLayoutFileName = layoutFileName; mFieldNamePrefix = fieldNamePrefix; mCreateHolder = createHolder; }
public ExtractClassProcessor( PsiClass sourceClass, List<PsiField> fields, List<PsiMethod> methods, List<PsiClass> classes, String packageName, MoveDestination moveDestination, String newClassName, String newVisibility, boolean generateAccessors, List<MemberInfo> enumConstants) { super(sourceClass.getProject()); this.sourceClass = sourceClass; this.newPackageName = packageName; myMoveDestination = moveDestination; myNewVisibility = newVisibility; myGenerateAccessors = generateAccessors; this.enumConstants = new ArrayList<PsiField>(); for (MemberInfo constant : enumConstants) { if (constant.isChecked()) { this.enumConstants.add((PsiField) constant.getMember()); } } this.fields = new ArrayList<PsiField>(fields); this.methods = new ArrayList<PsiMethod>(methods); this.innerClasses = new ArrayList<PsiClass>(classes); this.newClassName = newClassName; delegateFieldName = calculateDelegateFieldName(); requiresBackpointer = new BackpointerUsageVisitor(fields, innerClasses, methods, sourceClass) .backpointerRequired(); if (requiresBackpointer) { ContainerUtil.addAll(typeParams, sourceClass.getTypeParameters()); } else { final Set<PsiTypeParameter> typeParamSet = new HashSet<PsiTypeParameter>(); final TypeParametersVisitor visitor = new TypeParametersVisitor(typeParamSet); for (PsiField field : fields) { field.accept(visitor); } for (PsiMethod method : methods) { method.accept(visitor); // do not include method's type parameters in class signature typeParamSet.removeAll(Arrays.asList(method.getTypeParameters())); } typeParams.addAll(typeParamSet); } myClass = new WriteCommandAction<PsiClass>(myProject, getCommandName()) { @Override protected void run(@NotNull Result<PsiClass> result) throws Throwable { result.setResult(buildClass()); } }.execute().getResultObject(); myExtractEnumProcessor = new ExtractEnumProcessor(myProject, this.enumConstants, myClass); }
// todo: inline private static void generateBean( final PsiClass aClass, final String[] properties, final HashMap<String, String> property2fqClassName) throws MyException { final StringBuffer membersBuffer = new StringBuffer(); final StringBuffer methodsBuffer = new StringBuffer(); final CodeStyleManager formatter = CodeStyleManager.getInstance(aClass.getProject()); final JavaCodeStyleManager styler = JavaCodeStyleManager.getInstance(aClass.getProject()); for (final String property : properties) { LOG.assertTrue(property != null); final String type = property2fqClassName.get(property); LOG.assertTrue(type != null); generateProperty(styler, property, type, membersBuffer, methodsBuffer); } final PsiClass fakeClass; try { fakeClass = JavaPsiFacade.getInstance(aClass.getProject()) .getElementFactory() .createClassFromText(membersBuffer.toString() + methodsBuffer.toString(), null); final PsiField[] fields = fakeClass.getFields(); for (final PsiField field : fields) { aClass.add(field); } final PsiMethod[] methods = fakeClass.getMethods(); for (final PsiMethod method : methods) { aClass.add(method); } styler.shortenClassReferences(aClass); formatter.reformat(aClass); } catch (IncorrectOperationException e) { throw new MyException(e.getMessage()); } }
public PullUpProcessor( PsiClass sourceClass, PsiClass targetSuperClass, MemberInfo[] membersToMove, DocCommentPolicy javaDocPolicy) { super(sourceClass.getProject()); mySourceClass = sourceClass; myTargetSuperClass = targetSuperClass; myMembersToMove = membersToMove; myJavaDocPolicy = javaDocPolicy; }
@NotNull public static PsiClassType[] getExtendsListTypes(@NotNull PsiClass psiClass) { if (psiClass.isEnum()) { PsiClassType enumSuperType = getEnumSuperType( psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory()); return enumSuperType == null ? PsiClassType.EMPTY_ARRAY : new PsiClassType[] {enumSuperType}; } if (psiClass.isAnnotationType()) { return new PsiClassType[] { getAnnotationSuperType( psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory()) }; } final PsiReferenceList extendsList = psiClass.getExtendsList(); if (extendsList != null) { return extendsList.getReferencedTypes(); } return PsiClassType.EMPTY_ARRAY; }
static List<? extends LookupElement> wrap( @NotNull JavaPsiClassReferenceElement classItem, @NotNull PsiElement position) { PsiClass psiClass = classItem.getObject(); return wrap( classItem, psiClass, position, () -> JavaPsiFacade.getElementFactory(psiClass.getProject()) .createType(psiClass, PsiSubstitutor.EMPTY)); }
@NotNull public static PsiClassType createListType(@NotNull PsiClass elements) { JavaPsiFacade facade = JavaPsiFacade.getInstance(elements.getProject()); GlobalSearchScope resolveScope = elements.getResolveScope(); PsiClass listClass = facade.findClass(JAVA_UTIL_LIST, resolveScope); if (listClass == null) { return facade.getElementFactory().createTypeByFQClassName(JAVA_UTIL_LIST, resolveScope); } return facade .getElementFactory() .createType(listClass, facade.getElementFactory().createType(elements)); }