Java Code Examples for com.intellij.psi.JavaPsiFacade#getElementFactory()

@VisibleForTesting
static PsiExpression createMethodChain(
    Project project, String firstName, List<? extends String> methodNames) {
  PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
  StringBuilder expressionText =
      new StringBuilder(firstName + "(" + TEMPLATE_INSERT_PLACEHOLDER_C + ")");
  methodNames.forEach(
      methodName ->
          expressionText
              .append("\n.")
              .append(methodName)
              .append("(")
              .append(TEMPLATE_INSERT_PLACEHOLDER)
              .append(")"));
  return factory.createExpressionFromText(expressionText.toString(), null);
}
 

/**
 * Adds comment to the given method "// An event handler ContextClassName.methodName(c,
 * parameterName)
 */
public static void addComment(PsiClass contextClass, PsiMethod method) {
  final Project project = contextClass.getProject();
  final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);

  final StringBuilder builder =
      new StringBuilder("// An event handler ")
          .append(LithoPluginUtils.getLithoComponentNameFromSpec(contextClass.getName()))
          .append(".")
          .append(method.getName())
          .append("(")
          .append(CONTEXT_PARAMETER_NAME);
  for (PsiParameter parameter : method.getParameterList().getParameters()) {
    if (LithoPluginUtils.isParam(parameter)) {
      builder.append(", ").append(parameter.getName());
    }
  }

  builder.append(")");
  final PsiComment comment = factory.createCommentFromText(builder.toString(), method);
  method.addBefore(comment, method.getModifierList());
}
 

private PsiMethod readMethodTemplate(String targetName, Project project) {
  // TemplateSettings#loadDefaultLiveTemplates
  PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
  return Optional.ofNullable(
          DecodeDefaultsUtil.getDefaultsInputStream(this, "methodTemplates/methods"))
      .map(TemplateService::load)
      .filter(element -> TAG_ROOT.equals(element.getName()))
      .map(element -> element.getChild(targetName))
      .map(template -> template.getAttributeValue("method"))
      .map(method -> factory.createMethodFromText(method, null))
      .orElse(null);
}
 

public List<ReferenceableBeanId> findReferenceableBeanIdsByType(Module module,
                                                                Predicate<String> idCondition,
                                                                PsiType expectedBeanType) {
    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(module.getProject());
    return findReferenceableBeanIds(module, idCondition).stream()
            .filter(ref -> {
                PsiClass psiClass = resolveToPsiClass(ref);
                if (psiClass != null) {
                    PsiClassType beanType = elementFactory.createType(psiClass);
                    return expectedBeanType.isAssignableFrom(beanType);
                }
                return false;
            })
            .collect(Collectors.toList());
}
 

public DataWriter(PsiFile file, Project project, PsiClass cls) {
    super(project, file);
    factory = JavaPsiFacade.getElementFactory(project);
    this.file = file;
    this.project = project;
    this.cls = cls;
}
 

/**
 * Generate and insert the Parcel and ParcelablePlease code
 */
public void generate() {

  PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject());
  JavaCodeStyleManager styleManager = JavaCodeStyleManager.getInstance(psiClass.getProject());

  // Clear any previous
  clearPrevious();

  // Implements parcelable
  makeClassImplementParcelable(elementFactory, styleManager);

  // @ParcelablePlease Annotation
  addAnnotation(elementFactory, styleManager);

  // Creator
  PsiField creatorField = elementFactory.createFieldFromText(generateCreator(), psiClass);

  // Describe contents method
  PsiMethod describeContentsMethod =
      elementFactory.createMethodFromText(generateDescribeContents(), psiClass);

  // Method for writing to the parcel
  PsiMethod writeToParcelMethod =
      elementFactory.createMethodFromText(generateWriteToParcel(), psiClass);

  styleManager.shortenClassReferences(
      psiClass.addBefore(describeContentsMethod, psiClass.getLastChild()));

  styleManager.shortenClassReferences(
      psiClass.addBefore(writeToParcelMethod, psiClass.getLastChild()));

  styleManager.shortenClassReferences(psiClass.addBefore(creatorField, psiClass.getLastChild()));
}
 

@Override
@NotNull
public PsiAnnotation addAnnotation(@NotNull @NonNls String qualifiedName) {
  final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(getProject());
  final PsiAnnotation psiAnnotation = elementFactory.createAnnotationFromText('@' + qualifiedName, null);
  myAnnotations.put(qualifiedName, psiAnnotation);
  return psiAnnotation;
}
 

protected void processClass(@NotNull PsiClass psiClass) {
  final PsiElementFactory factory = JavaPsiFacade.getElementFactory(psiClass.getProject());
  final PsiClassType stringClassType = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_STRING, psiClass.getResolveScope());

  final PsiMethod toStringMethod = findPublicNonStaticMethod(psiClass, "toString", stringClassType);
  if (null != toStringMethod) {
    toStringMethod.delete();
  }
  addAnnotation(psiClass, ToString.class);
}
 

public static LocalQuickFix createAddAnnotationQuickFix(@NotNull PsiClass psiClass, @NotNull String annotationFQN, @Nullable String annotationParam) {
  PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiClass.getProject());
  PsiAnnotation newAnnotation = elementFactory.createAnnotationFromText("@" + annotationFQN + "(" + StringUtil.notNullize(annotationParam) + ")", psiClass);
  final PsiNameValuePair[] attributes = newAnnotation.getParameterList().getAttributes();

  return new AddAnnotationFix(annotationFQN, psiClass, attributes);
}
 

private boolean isAssignableFrom(PsiType type, PsiClass value) {
    PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(value.getProject());
    PsiClassType valueType = elementFactory.createType(value);
    return type.isAssignableFrom(valueType);
}
 

@NotNull
@Override
public PsiEnumConstantInitializer getOrCreateInitializingClass() {
  final PsiElementFactory factory = JavaPsiFacade.getElementFactory(getProject());
  return factory.createEnumConstantFromText("foo{}", null).getInitializingClass();
}
 

@NotNull
public static PsiCodeBlock createCodeBlockFromText(@NotNull String blockText, @NotNull PsiElement psiElement) {
  final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(psiElement.getProject());
  return elementFactory.createCodeBlockFromText("{" + blockText + "}", psiElement);
}