private void injectAnnotation(PsiElementFactory factory, PsiClass generateClass) { if (factory == null || generateClass == null) { return; } PsiModifierList modifierList = generateClass.getModifierList(); PsiElement firstChild = modifierList.getFirstChild(); Pattern pattern = Pattern.compile("@.*?JsonIgnoreProperties"); if (firstChild != null && !pattern.matcher(firstChild.getText()).find()) { PsiAnnotation annotationFromText = factory.createAnnotationFromText("@com.fasterxml.jackson.annotation.JsonIgnoreProperties(ignoreUnknown = true)", generateClass); modifierList.addBefore(annotationFromText, firstChild); } } }
@Override public void run() { cls.add(factory.createMethodFromText(method, cls)); }
try { PsiMethod setMethod = factory .createMethodFromText(factory.createMethod(setName, returnSelf ? factory.createType(containingClass) : PsiType.VOID).getText(), field); String parameterName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.PARAMETER); PsiParameter param = factory.createParameter(parameterName, field.getType()); PsiCodeBlock body = factory.createCodeBlockFromText(buffer.toString(), null); setMethod.getBody().replace(body); setMethod = (PsiMethod)CodeStyleManager.getInstance(project).reformat(setMethod);
public void testQuickFix_classWithNullaryConstructor() { ProblemDescriptorImpl problemDescriptorMock = mock(ProblemDescriptorImpl.class); MockitoAnnotations.initMocks(this); PsiElementFactory factory = JavaPsiFacade.getInstance(myFixture.getProject()).getElementFactory(); PsiClass psiClass = factory.createClass(getName()); PsiMethod nullaryConstructor = factory.createMethodFromText("public " + psiClass.getName() + "() { }", psiClass); psiClass.addAfter(nullaryConstructor, null); ConstructorInspection constructorInspection = new ConstructorInspection(); ConstructorInspection.MyQuickFix myQuickFix = constructorInspection.new MyQuickFix(psiClass); myQuickFix.applyFix(myFixture.getProject(), problemDescriptorMock); Assert.assertEquals(1, psiClass.getConstructors().length); Assert.assertTrue(EndpointUtilities.isPublicNullaryConstructor(psiClass.getConstructors()[0])); }
/** * Returns set of endpoint injected types. * * @param project The current project. * @return Set of injected types. */ private static Set<PsiClassType> createInjectedClassTypes(Project project) { Set<PsiClassType> injectedClassTypes = new HashSet<PsiClassType>(); injectedClassTypes.add( JavaPsiFacade.getElementFactory(project) .createTypeByFQClassName("com.google.appengine.api.users.User")); injectedClassTypes.add( JavaPsiFacade.getElementFactory(project) .createTypeByFQClassName("javax.servlet.http.HttpServletRequest")); injectedClassTypes.add( JavaPsiFacade.getElementFactory(project) .createTypeByFQClassName("javax.servlet.ServletContext")); return Collections.unmodifiableSet(injectedClassTypes); }
PsiJavaCodeReferenceElement ref1; if (exceptionName != null) { ref1 = factory.createReferenceElementByFQClassName(exceptionName, method.getResolveScope()); PsiClassType type = factory.createType(exceptionClass); ref1 = factory.createReferenceElementByType(type); PsiJavaCodeReferenceElement ref; if (exceptionName != null) { ref = factory.createReferenceElementByFQClassName(exceptionName, method.getResolveScope()); PsiClassType type = factory.createType(exceptionClass); ref = factory.createReferenceElementByType(type);
/** * Tests that the Quick fix for a parameter with no annotation returns the same parameter * unchanged. */ public void testQuickFix_noAnnotation() { Project myProject = myFixture.getProject(); PsiParameter parameter = JavaPsiFacade.getInstance(myProject) .getElementFactory() .createParameter("param", PsiType.BOOLEAN); runQuickFixTest(parameter, "boolean param"); }
private static PsiExpression getBoxedArgument(PsiExpression arg) throws IncorrectOperationException { arg = PsiUtil.deparenthesizeExpression(arg); assert arg != null; if (PsiUtil.isLanguageLevel5OrHigher(arg)) { return arg; } final PsiType type = arg.getType(); if (!(type instanceof PsiPrimitiveType) || type.equals(PsiType.NULL)) { return arg; } final PsiPrimitiveType primitiveType = (PsiPrimitiveType)type; final String boxedQName = primitiveType.getBoxedTypeName(); if (boxedQName == null) { return arg; } final GlobalSearchScope resolveScope = arg.getResolveScope(); final PsiElementFactory factory = JavaPsiFacade.getElementFactory(arg.getProject()); final PsiJavaCodeReferenceElement ref = factory.createReferenceElementByFQClassName(boxedQName, resolveScope); final PsiNewExpression newExpr = (PsiNewExpression)factory.createExpressionFromText("new A(b)", null); final PsiElement classRef = newExpr.getClassReference(); assert classRef != null; classRef.replace(ref); final PsiExpressionList argumentList = newExpr.getArgumentList(); assert argumentList != null; argumentList.getExpressions()[0].replace(arg); return newExpr; }
/** * Consider using {@link com.intellij.codeInsight.generation.GenerateMembersUtil#generateGetterPrototype(com.intellij.psi.PsiField)} or * {@link com.intellij.codeInsight.generation.GenerateMembersUtil#generateSimpleGetterPrototype(com.intellij.psi.PsiField)} * to add @Override annotation */ @Nullable public static PsiMethod generateGetterPrototype(@NotNull PsiField field) { PsiElementFactory factory = JavaPsiFacade.getInstance(field.getProject()).getElementFactory(); Project project = field.getProject(); String name = field.getName(); String getName = suggestGetterName(field); try { PsiMethod getMethod = factory.createMethod(getName, field.getType()); PsiUtil.setModifierProperty(getMethod, PsiModifier.PUBLIC, true); if (field.hasModifierProperty(PsiModifier.STATIC)) { PsiUtil.setModifierProperty(getMethod, PsiModifier.STATIC, true); } annotateWithNullableStuff(field, getMethod); PsiCodeBlock body = factory.createCodeBlockFromText("{\nreturn " + name + ";\n}", null); getMethod.getBody().replace(body); getMethod = (PsiMethod)CodeStyleManager.getInstance(project).reformat(getMethod); return getMethod; } catch (IncorrectOperationException e) { LOG.error(e); return null; } }
final PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); final GlobalSearchScope resolveScope = GlobalSearchScope.allScope(manager.getProject()); final PsiClassType cloneable = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_CLONEABLE, resolveScope); final PsiClassType serializable = factory.createTypeByFQClassName(CommonClassNames.JAVA_IO_SERIALIZABLE, resolveScope); return PsiIntersectionType.createIntersection(componentType, cloneable, serializable); conjuncts[i] = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(aSuper, substitutor); PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory(); GlobalSearchScope all = GlobalSearchScope.allScope(manager.getProject()); PsiClassType serializable = factory.createTypeByFQClassName(CommonClassNames.JAVA_IO_SERIALIZABLE, all); PsiClassType cloneable = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_CLONEABLE, all); PsiType arraySupers = PsiIntersectionType.createIntersection(serializable, cloneable); return getLeastUpperBound(arraySupers, type2, compared, manager);
@Override protected void run(Result result) throws Throwable { IdeDocumentHistory.getInstance(project).includeCurrentPlaceAsChangePlace(); PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory(); PsiJavaCodeReferenceElement ref = baseClass == null ? null : elementFactory.createReferenceElementByFQClassName( baseClass, GlobalSearchScope.allScope(project)); try { PsiClass resultClass = JavaDirectoryService.getInstance().createClass(targetDirectory, className); resultRef.set(resultClass); if (ref != null) { PsiElement baseClass = ref.resolve(); boolean isInterface = baseClass instanceof PsiClass && ((PsiClass) baseClass).isInterface(); PsiReferenceList targetReferenceList = isInterface ? resultClass.getImplementsList() : resultClass.getExtendsList(); assert targetReferenceList != null; targetReferenceList.add(ref); } if (consumer != null) { consumer.consume(resultClass); } } catch (final IncorrectOperationException e) { ApplicationManager.getApplication().invokeLater( () -> Messages.showErrorDialog(project, "Unable to create class " + className + "\n" + e.getLocalizedMessage(), title)); } } }.execute();
public void testQuickFix() { PsiMethod someFunction = JavaPsiFacade.getInstance(myFixture.getProject()) .getElementFactory() .createMethod("someFunction", PsiType.VOID); MockProblemDescriptor problemDescriptor = new MockProblemDescriptor(someFunction, "", ProblemHighlightType.ERROR); FullJavaNameInspection.MyQuickFix myQuickFix = new FullJavaNameInspection().new MyQuickFix(); myQuickFix.applyFix(myFixture.getProject(), problemDescriptor); assertEquals("someFunction_1", someFunction.getName()); myQuickFix.applyFix(myFixture.getProject(), problemDescriptor); assertEquals("someFunction_1_1", someFunction.getName()); }
public void testQuickFix_classWithNonNullaryConstructor() { ProblemDescriptorImpl problemDescriptorMock = mock(ProblemDescriptorImpl.class); MockitoAnnotations.initMocks(this); PsiElementFactory factory = JavaPsiFacade.getInstance(myFixture.getProject()).getElementFactory(); PsiClass psiClass = factory.createClass(getName()); PsiMethod nullaryConstructor = factory.createMethodFromText( "public " + psiClass.getName() + "(String param) { }", psiClass); psiClass.addAfter(nullaryConstructor, null); ConstructorInspection constructorInspection = new ConstructorInspection(); ConstructorInspection.MyQuickFix myQuickFix = constructorInspection.new MyQuickFix(psiClass); myQuickFix.applyFix(myFixture.getProject(), problemDescriptorMock); Assert.assertEquals(2, psiClass.getConstructors().length); Assert.assertTrue(EndpointUtilities.isPublicNullaryConstructor(psiClass.getConstructors()[0])); }
Set<PsiClassType> parameterTypes = new HashSet<PsiClassType>(); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Enum")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.String")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Boolean")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Integer")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Long")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Float")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.lang.Double")); parameterTypes.add( JavaPsiFacade.getElementFactory(project).createTypeByFQClassName("java.util.Date")); parameterTypes.add( JavaPsiFacade.getElementFactory(project) .createTypeByFQClassName("com.google.api.server.spi.types.DateAndTime")); parameterTypes.add( JavaPsiFacade.getElementFactory(project) .createTypeByFQClassName("com.google.api.server.spi.types.SimpleDate"));
/** Test that the Quick fix for a parameter with @Named returns the same parameter unchanged. */ public void testQuickFix_withNamedAnnotation() { Project myProject = myFixture.getProject(); PsiParameter parameter = JavaPsiFacade.getInstance(myProject) .getElementFactory() .createParameter("param", PsiType.BOOLEAN); parameter.getModifierList().addAnnotation(GctConstants.APP_ENGINE_ANNOTATION_NAMED); runQuickFixTest(parameter, "@" + GctConstants.APP_ENGINE_ANNOTATION_NAMED + " boolean param"); }
private void injectAnnotation(PsiElementFactory factory, PsiClass generateClass) { if (factory == null || generateClass == null) { return; } PsiModifierList modifierList = generateClass.getModifierList(); if (modifierList != null) { PsiElement firstChild = modifierList.getFirstChild(); Pattern pattern = Pattern.compile("@.*?NoArgsConstructor"); if (firstChild != null && !pattern.matcher(firstChild.getText()).find()) { PsiAnnotation annotationFromText = factory.createAnnotationFromText("@lombok.NoArgsConstructor", generateClass); modifierList.addBefore(annotationFromText, firstChild); } Pattern pattern2 = Pattern.compile("@.*?Data"); if (firstChild != null && !pattern2.matcher(firstChild.getText()).find()) { PsiAnnotation annotationFromText = factory.createAnnotationFromText("@lombok.Data", generateClass); modifierList.addBefore(annotationFromText, firstChild); } } }
@Override public void run() { cls.add(factory.createMethodFromText(finalMethod, cls)); }
/** * Returns the class type for qualified class name. * * @param qName qualified class name. * @param project * @param resolveScope the scope in which the class is searched. * @return the class instance. */ public static PsiClassType getTypeByName(String qName, Project project, GlobalSearchScope resolveScope) { PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory(); return factory.createTypeByFQClassName(qName, resolveScope); }
/** * Tests that the Quick fix for a parameter with the javax @Nullable returns the parameter * without @Nullable. */ public void testQuickFix_withJavaxNullableAnnotation() { Project myProject = myFixture.getProject(); PsiParameter parameter = JavaPsiFacade.getInstance(myProject) .getElementFactory() .createParameter("param", PsiType.BOOLEAN); parameter.getModifierList().addAnnotation("javax.annotation.Nullable"); runQuickFixTest(parameter, " boolean param"); }
private void injectAnnotation(PsiElementFactory factory, PsiClass generateClass) { if (factory == null || generateClass == null) { return; } PsiModifierList modifierList = generateClass.getModifierList(); if (modifierList != null) { PsiElement firstChild = modifierList.getFirstChild(); Pattern pattern = Pattern.compile("@.*?JsonObject"); if (firstChild != null && !pattern.matcher(firstChild.getText()).find()) { PsiAnnotation annotationFromText = factory.createAnnotationFromText("@com.bluelinelabs.logansquare.annotation.JsonObject", generateClass); modifierList.addBefore(annotationFromText, firstChild); } } } }