com.intellij.psi.PsiTypeParameter#com.intellij.psi.PsiParameter源码实例Demo

/**
 * 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());
}
 

static void addCompletionResult(
    @NotNull CompletionResultSet completionResultSet,
    PsiMethod currentMethod,
    PsiMethod[] allMethods,
    Predicate<PsiParameter> annotationCheck) {
  // Don't propose completion with current method parameters
  Set<String> excludingParameters =
      Stream.of(currentMethod.getParameterList().getParameters())
          .filter(annotationCheck)
          .map(PsiParameter::getName)
          .filter(Objects::nonNull)
          .collect(Collectors.toSet());

  LithoPluginUtils.getPsiParameterStream(currentMethod, allMethods)
      .filter(annotationCheck)
      .filter(parameter -> !excludingParameters.contains(parameter.getName()))
      .map(StatePropCompletionContributor::createCompletionResult)
      .forEach(completionResultSet::addElement);
}
 

@Override
protected boolean isRowEditable(int row) {
  // If table parameter is an initial method parameter, than it's not editable.
  if (row == 0) {
    stopEditing();
  }
  final List<ParameterTableModelItemBase<ParameterInfoImpl>> currentTableItems =
      myParametersTableModel.getItems();
  if (row > currentTableItems.size()) {
    return true;
  }
  final ParameterInfoImpl parameterInfo = currentTableItems.get(row).parameter;
  final PsiParameter initialMethodParameter =
      getInitialMethodParameter(parameterInfo.getName(), parameterInfo.getTypeText());
  return initialMethodParameter == null;
}
 

/** @return method based on user choice. */
@Override
protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) {
  return Optional.ofNullable(eventChooser.choose(aClass, project))
      .map(
          eventClass -> {
            final List<PsiParameter> propsAndStates =
                LithoPluginUtils.getPsiParameterStream(null, aClass.getMethods())
                    .filter(LithoPluginUtils::isPropOrState)
                    .collect(Collectors.toList());
            return OnEventGenerateUtils.createOnEventMethod(aClass, eventClass, propsAndStates);
          })
      .map(onEventMethod -> onEventRefactorer.changeSignature(project, onEventMethod, aClass))
      .map(
          customMethod -> {
            OnEventGenerateUtils.addComment(aClass, customMethod);
            onEventGeneratedListener.onGenerated(customMethod);
            return new ClassMember[] {new PsiMethodMember(customMethod)};
          })
      .orElse(ClassMember.EMPTY_ARRAY);
}
 

@Nullable
@Override
public ProblemDescriptor[] checkMethod(
    @NotNull PsiMethod method, @NotNull InspectionManager manager, boolean isOnTheFly) {
  if (!LithoPluginUtils.isLithoSpec(method.getContainingClass())) {
    return ProblemDescriptor.EMPTY_ARRAY;
  }
  return Optional.of(method)
      .map(PsiMethod::getParameterList)
      .map(PsiParameterList::getParameters)
      .map(
          psiParameters ->
              Stream.of(psiParameters)
                  .filter(LithoPluginUtils::isPropOrState)
                  .filter(UppercaseStatePropInspection::isFirstLetterCapital)
                  .map(PsiParameter::getNameIdentifier)
                  .filter(Objects::nonNull)
                  .map(identifier -> createWarning(identifier, manager, isOnTheFly))
                  .toArray(ProblemDescriptor[]::new))
      .orElse(ProblemDescriptor.EMPTY_ARRAY);
}
 

static List<MethodParamModel> getMethodParams(
    PsiMethod method,
    List<Class<? extends Annotation>> permittedAnnotations,
    List<Class<? extends Annotation>> permittedInterStageInputAnnotations,
    List<Class<? extends Annotation>> delegateMethodAnnotationsThatSkipDiffModels) {

  final List<MethodParamModel> methodParamModels = new ArrayList<>();
  PsiParameter[] params = method.getParameterList().getParameters();

  for (final PsiParameter param : params) {
    methodParamModels.add(
        MethodParamModelFactory.create(
            PsiTypeUtils.generateTypeSpec(param.getType()),
            param.getName(),
            getLibraryAnnotations(param, permittedAnnotations),
            getExternalAnnotations(param),
            permittedInterStageInputAnnotations,
            canCreateDiffModels(method, delegateMethodAnnotationsThatSkipDiffModels),
            param));
  }

  return methodParamModels;
}
 

private static List<AnnotationSpec> getExternalAnnotations(PsiParameter param) {
  PsiAnnotation[] annotationsOnParam = AnnotationUtil.getAllAnnotations(param, false, null);
  final List<AnnotationSpec> annotations = new ArrayList<>();

  for (PsiAnnotation annotationOnParam : annotationsOnParam) {
    if (annotationOnParam.getQualifiedName().startsWith(COMPONENTS_PACKAGE)) {
      continue;
    }

    final AnnotationSpec.Builder annotationSpec =
        AnnotationSpec.builder(PsiTypeUtils.guessClassName(annotationOnParam.getQualifiedName()));

    PsiNameValuePair[] paramAttributes = annotationOnParam.getParameterList().getAttributes();
    for (PsiNameValuePair attribute : paramAttributes) {
      annotationSpec.addMember(attribute.getName(), attribute.getDetachedValue().getText());
    }

    annotations.add(annotationSpec.build());
  }

  return annotations;
}
 

@Test
public void defaultValues() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        assertNotNull(prop);
        assertFalse(prop.optional());
        assertFalse(prop.isCommonProp());
        assertFalse(prop.overrideCommonPropBehavior());
        assertFalse(prop.dynamic());
        assertEquals(ResType.NONE, prop.resType());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void setValues() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[1], Prop.class);
        assertNotNull(prop);
        assertTrue(prop.optional());
        assertTrue(prop.isCommonProp());
        assertTrue(prop.overrideCommonPropBehavior());
        assertTrue(prop.dynamic());
        assertEquals(ResType.DRAWABLE, prop.resType());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyEquals_equal() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[2], Prop.class);
        // Calls proxy
        assertEquals(prop1, prop2);

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyEquals_not_equal() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[1], Prop.class);
        // Calls proxy
        assertNotEquals(prop1, prop2);

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyHashCode() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop1 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        Prop prop2 = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[2], Prop.class);
        Set<Prop> props = new HashSet<>(1);
        props.add(prop1);
        props.add(prop2);
        // Calls proxy
        assertEquals(1, props.size());

        return true;
      },
      "WithAnnotationClass.java");
}
 

@Test
public void proxyToString() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertNotNull(psiClasses);
        PsiClass psiClass = psiClasses.get(0);
        PsiParameter[] parameters =
            PsiTreeUtil.findChildOfType(psiClass, PsiParameterList.class).getParameters();

        Prop prop = PsiAnnotationProxyUtils.findAnnotationInHierarchy(parameters[0], Prop.class);
        // Calls proxy
        assertEquals("@com.facebook.litho.annotations.Prop()", prop.toString());

        return true;
      },
      "WithAnnotationClass.java");
}
 

/**
 * Finds and removes a given method
 * @param methodName
 * @param arguments
 */
private void findAndRemoveMethod(String methodName, String... arguments) {
  // Maybe there's an easier way to do this with mClass.findMethodBySignature(), but I'm not an expert on Psi*
  PsiMethod[] methods = psiClass.findMethodsByName(methodName, false);

  for (PsiMethod method : methods) {
    PsiParameterList parameterList = method.getParameterList();

    if (parameterList.getParametersCount() == arguments.length) {
      boolean shouldDelete = true;

      PsiParameter[] parameters = parameterList.getParameters();

      for (int i = 0; i < arguments.length; i++) {
        if (!parameters[i].getType().getCanonicalText().equals(arguments[i])) {
          shouldDelete = false;
        }
      }

      if (shouldDelete) {
        method.delete();
      }
    }
  }
}
 

public void testIntParameter() {
  myFixture.configureByText("a.java", "import lombok.val;\n" +
    "abstract class Test {\n" +
    "    private void test() {\n" +
    "       int[] myArray = new int[] {1, 2, 3, 4, 5};\n" +
    "       for(val my<caret>Var: myArray) {" +
    "       }\n" +
    "    } \n" +
    "}\n");

  final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
  assertTrue(elementAtCaret instanceof PsiIdentifier);
  final PsiElement localParameter = elementAtCaret.getParent();
  assertTrue(localParameter.toString(), localParameter instanceof PsiParameter);
  final PsiType type = ((PsiParameter) localParameter).getType();
  assertNotNull(localParameter.toString(), type);
  assertTrue(type.getCanonicalText(), type.equalsToText("int"));
}
 

public void testIntParameter() {
  myFixture.configureByText("a.java", "import lombok.experimental.var;\n" +
    "abstract class Test {\n" +
    "    private void test() {\n" +
    "       int[] myArray = new int[] {1, 2, 3, 4, 5};\n" +
    "       for(var my<caret>Var: myArray) {" +
    "       }\n" +
    "    } \n" +
    "}\n");
  final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
  assertTrue(elementAtCaret instanceof PsiIdentifier);
  final PsiElement localParameter = elementAtCaret.getParent();
  assertTrue(localParameter.toString(), localParameter instanceof PsiParameter);
  final PsiType type = ((PsiParameter) localParameter).getType();
  assertNotNull(localParameter.toString(), type);
  assertTrue(type.getCanonicalText(), type.equalsToText("int"));
}
 

@Override public boolean shouldShow(UsageTarget target, Usage usage) {
  PsiElement element = ((UsageInfo2UsageAdapter) usage).getElement();

  PsiField field = PsiConsultantImpl.findField(element);
  if (field != null //
      && PsiConsultantImpl.hasAnnotation(field, CLASS_INJECT) //
      && PsiConsultantImpl.hasQuailifierAnnotations(field, qualifierAnnotations)
      && PsiConsultantImpl.hasTypeParameters(field, typeParameters)) {
    return true;
  }

  PsiMethod method = PsiConsultantImpl.findMethod(element);
  if (method != null && (PsiConsultantImpl.hasAnnotation(method, CLASS_INJECT)
          || PsiConsultantImpl.hasAnnotation(method, CLASS_PROVIDES))) {
    for (PsiParameter parameter : method.getParameterList().getParameters()) {
      PsiClass parameterClass = PsiConsultantImpl.checkForLazyOrProvider(parameter);
      if (parameterClass.equals(returnType) && PsiConsultantImpl.hasQuailifierAnnotations(
          parameter, qualifierAnnotations)
          && PsiConsultantImpl.hasTypeParameters(parameter, typeParameters)) {
        return true;
      }
    }
  }

  return false;
}
 

@Override public void navigate(final MouseEvent mouseEvent, PsiElement psiElement) {
  if (!(psiElement instanceof PsiMethod)) {
    throw new IllegalStateException("Called with non-method: " + psiElement);
  }

  PsiMethod psiMethod = (PsiMethod) psiElement;
  PsiParameter[] parameters = psiMethod.getParameterList().getParameters();
  if (parameters.length == 1) {
    showUsages(mouseEvent, parameters[0]);
  } else {
    new PickTypeAction().startPickTypes(new RelativePoint(mouseEvent), parameters,
        new PickTypeAction.Callback() {
          @Override public void onParameterChosen(PsiParameter selected) {
            showUsages(mouseEvent, selected);
          }
        });
  }
}
 

private boolean navigateToConstructorIfProvider(PsiParameter psiParameter) {
  PsiTypeElement declaringTypeElement = psiParameter.getTypeElement();
  PsiClass classElement = JavaPsiFacade.getInstance(psiParameter.getProject()).findClass(
          declaringTypeElement.getType().getCanonicalText(),
          declaringTypeElement.getResolveScope());

  if (classElement == null) {
    return false;
  }

  for (PsiMethod method : classElement.getConstructors()) {
    if (PsiConsultantImpl.hasAnnotation(method, CLASS_INJECT) && navigateToElement(method)) {
        return true;
    }
  }
  return false;
}
 

static boolean areParameterListsEqual(PsiParameterList paramList1, PsiParameterList paramList2) {
    if (paramList1.getParametersCount() != paramList2.getParametersCount()) {
        return false;
    }

    final PsiParameter[] param1Params = paramList1.getParameters();
    final PsiParameter[] param2Params = paramList2.getParameters();
    for (int i = 0; i < param1Params.length; i++) {
        final PsiParameter param1Param = param1Params[i];
        final PsiParameter param2Param = param2Params[i];

        if (!areTypesPresentableEqual(param1Param.getType(), param2Param.getType())) {
            return false;
        }
    }

    return true;
}
 

/**
 * 获取方法内部的变量
 *
 * @param psiMethod psi方法
 * @return {@link java.util.Map<java.lang.String,java.lang.Object>}
 */
private Map<String, Object> getMethodInnerVariable(PsiMethod psiMethod) {
    Map<String, Object> map = Maps.newHashMap();
    map.put("author", config.getAuthor());
    map.put("methodName", psiMethod.getName());
    map.put("methodReturnType", psiMethod.getReturnType() == null ? "" : psiMethod.getReturnType().getPresentableText());
    map.put("methodParamTypes",
        Arrays.stream(psiMethod.getTypeParameters()).map(PsiTypeParameter::getQualifiedName).toArray(String[]::new));
    map.put("methodParamNames",
        Arrays.stream(psiMethod.getParameterList().getParameters()).map(PsiParameter::getName).toArray(String[]::new));
    return map;
}
 

@Override
public String generate(PsiElement element) {
    if (!(element instanceof PsiMethod)) {
        return "";
    }

    List<String> paramNameList = Arrays.stream(((PsiMethod)element).getParameterList().getParameters())
        .map(PsiParameter::getName).collect(Collectors.toList());
    if (paramNameList.isEmpty()) {
        return "";
    }
    return paramNameList.stream()
        .map(param -> "@param " + param + " " + translatorService.translate(param))
        .collect(Collectors.joining("\n"));
}
 

@Override
protected void processAnnotation(PsiModifierListOwner psiElement, PsiAnnotation configPropertyAnnotation,
								 String annotationName, SearchContext context) {
	if (psiElement instanceof PsiField || psiElement instanceof PsiMethod || psiElement instanceof PsiParameter) {
		IPropertiesCollector collector = context.getCollector();
		String name = AnnotationUtils.getAnnotationMemberValue(configPropertyAnnotation,
				QuarkusConstants.CONFIG_PROPERTY_ANNOTATION_NAME);
		if (StringUtils.isNotEmpty(name)) {
			String propertyTypeName = "";
			if (psiElement instanceof PsiField) {
				propertyTypeName = PsiTypeUtils.getResolvedTypeName((PsiField) psiElement);
			} else if (psiElement instanceof PsiMethod) {
				propertyTypeName = PsiTypeUtils.getResolvedResultTypeName((PsiMethod) psiElement);
			} else if (psiElement instanceof PsiVariable) {
				propertyTypeName = PsiTypeUtils.getResolvedTypeName((PsiVariable) psiElement);
			}
			PsiClass fieldClass = JavaPsiFacade.getInstance(psiElement.getProject()).findClass(propertyTypeName, GlobalSearchScope.allScope(psiElement.getProject()));

			String type = PsiTypeUtils.getPropertyType(fieldClass, propertyTypeName);
			String description = null;
			String sourceType = PsiTypeUtils.getSourceType(psiElement);
			String sourceField = null;
			String sourceMethod = null;
			if (psiElement instanceof PsiField || psiElement instanceof PsiMethod) {
				sourceField = PsiTypeUtils.getSourceField((PsiMember) psiElement);
			} else if (psiElement instanceof PsiParameter) {
				PsiMethod method = (PsiMethod) ((PsiParameter)psiElement).getDeclarationScope();
					sourceMethod = PsiTypeUtils.getSourceMethod(method);
			}
			String defaultValue = AnnotationUtils.getAnnotationMemberValue(configPropertyAnnotation,
					QuarkusConstants.CONFIG_PROPERTY_ANNOTATION_DEFAULT_VALUE);
			String extensionName = null;

			super.updateHint(collector, fieldClass);

			addItemMetadata(collector, name, type, description, sourceType, sourceField, sourceMethod, defaultValue,
					extensionName, PsiTypeUtils.isBinary(psiElement));
		}
	}
}
 

public static String getSourceType(PsiModifierListOwner psiElement) {
    if (psiElement instanceof PsiField || psiElement instanceof PsiMethod) {
        return ClassUtil.getJVMClassName(((PsiMember)psiElement).getContainingClass());
    } else if (psiElement instanceof PsiParameter) {
        return ClassUtil.getJVMClassName(((PsiMethod)((PsiParameter)psiElement).getDeclarationScope()).getContainingClass());
    }
    return null;
}
 

static LookupElement createCompletionResult(PsiParameter parameter) {
  return LookupElementBuilder.create(
      new StringJoiner(" ")
          .add(parameter.getType().getPresentableText())
          .add(parameter.getName())
          .toString());
}
 

/** @param method is used to fill the chooser table. It will not be modified. */
OnEventChangeSignatureDialog(Project project, PsiMethod method, PsiElement context) {
  super(project, new OnEventMethodDescriptor(method), false, context);
  // Save initial method parameters
  PsiParameter[] parameters = method.getParameterList().getParameters();
  for (PsiParameter parameter : parameters) {
    nameToParameter.put(parameter.getName(), parameter);
  }
}
 

/** @return parameter from initial method if name and type match any, null otherwise. */
@Nullable
// Package-private to be accessed from the inner class.
PsiParameter getInitialMethodParameter(String name, String type) {
  final PsiParameter parameter = nameToParameter.get(name);
  if (parameter == null) {
    return null;
  }
  if (parameter.getType().getPresentableText().equals(type)) {
    return parameter;
  }
  return null;
}
 

/** @return the Stream of unique parameters from all methods excluding current method. */
public static Stream<PsiParameter> getPsiParameterStream(
    @Nullable PsiMethod currentMethod, PsiMethod[] allMethods) {
  return Stream.of(allMethods)
      .filter(psiMethod -> !psiMethod.equals(currentMethod))
      .map(PsiMethod::getParameterList)
      .map(PsiParameterList::getParameters)
      .flatMap(Stream::of)
      .filter(distinctByKey(PsiParameter::getName));
}
 

private static List<Annotation> getLibraryAnnotations(
    PsiParameter param, List<Class<? extends Annotation>> permittedAnnotations) {
  List<Annotation> paramAnnotations = new ArrayList<>();
  for (Class<? extends Annotation> possibleMethodParamAnnotation : permittedAnnotations) {
    final Annotation paramAnnotation =
        PsiAnnotationProxyUtils.findAnnotationInHierarchy(param, possibleMethodParamAnnotation);
    if (paramAnnotation != null) {
      paramAnnotations.add(paramAnnotation);
    }
  }

  return paramAnnotations;
}
 

@Test
public void isProp() {
  PsiParameter prop =
      createWithAnnotation(PsiParameter.class, "com.facebook.litho.annotations.Prop");
  Assert.assertTrue(LithoPluginUtils.isProp(prop));

  PsiParameter notProp =
      createWithAnnotation(PsiParameter.class, "com.facebook.litho.annotations.PropDefault");
  Assert.assertFalse(LithoPluginUtils.isProp(notProp));

  PsiParameter notProp2 = createWithAnnotation(PsiParameter.class, "any.Prop");
  Assert.assertFalse(LithoPluginUtils.isProp(notProp2));
}