@Override protected void selectActionPerformed(AnActionEvent event, PsiElement element, String packageName) { if (!Utils.isAndroidClass(packageName)) { NotificationUtils.infoNotification("Must be Android class or Method"); return; } String linkUrl = BASE_URL; if (element instanceof PsiMethod) { PsiMethod psiMethod = (PsiMethod) element; PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); StringBuilder paramsBuilder = new StringBuilder("#" + psiMethod.getName()); paramsBuilder.append("("); for (int i = 0; i < parameters.length; i++) { PsiParameter parameter = parameters[i]; paramsBuilder.append(parameter.getType().getCanonicalText()); if (i < parameters.length - 1) { paramsBuilder.append(",%20"); } } paramsBuilder.append(")"); linkUrl += getRealPackage(psiMethod.getContainingClass()) + paramsBuilder.toString(); } else if (element instanceof PsiClass) { PsiClass psiClass = (PsiClass) element; linkUrl += getRealPackage(psiClass); } LOG.info("linkUrl= " + linkUrl); Utils.openUrl(linkUrl); }
public static CharSequence buildParamsList(PsiMethod method) { StringBuilder builder = new StringBuilder(128); builder.append('('); boolean first = true; final PsiParameterList parameterList = method.getParameterList(); for (PsiParameter param : parameterList.getParameters()) { if (first) { first = false; } else { builder.append(", "); } builder.append(getTypeName(param.getType())) .append(' ') .append(param.getName()); } builder.append(')'); return builder.toString(); }
/** * Checks if the parameter is annotated with the provided {@code annotation}. * * @param psiParameter the parameter on which we need to check for the annotation * @param annotation the annotation that we need to find * * @return {@code true} if the {@code psiParameter} is annotated with the {@code annotation}, {@code false} * otherwise */ private static boolean hasAnnotation(PsiParameter psiParameter, String annotation) { PsiModifierList modifierList = psiParameter.getModifierList(); return modifierList != null && modifierList.findAnnotation( annotation ) != null; }
@Nullable public static List<String> getParametersTypesList(PsiParameter[] psiParameters) { if (psiParameters.length == 0) { return null; } List<String> parameters = new ArrayList<>(); for (PsiParameter psiParameter : psiParameters) { if (psiParameter.getTypeElement() == null || psiParameter.getName() == null) { continue; } parameters.add(psiTypeToString(psiParameter.getTypeElement())); } return parameters; }
public void addAnnotationWithParameterName(@NotNull PsiParameter parameter) { String name = parameter.getName(); if (null != name) { AnnotationService.getInstance(parameter.getProject()).addAnnotation(parameter, Annotation.PARAM.withValue(new Annotation.StringValue(name))); } } }
PsiElement psiElement = psiParameter.getDeclarationScope(); if (psiElement instanceof PsiMethod) { if (!EndpointUtilities.isApiMethod((PsiMethod) psiElement)) { project = psiParameter.getContainingFile().getProject(); if (project == null) { return; LOG.error("Error getting project with parameter " + psiParameter.getText(), ex); return; if (!isValidArrayOrPrimitiveType(psiParameter.getType(), project)) { holder.registerProblem( psiParameter, "Illegal nested collection type " + psiParameter.getType().getPresentableText() + ".", LocalQuickFix.EMPTY_ARRAY);
private void validateMethodParameters(PsiParameter psiParameter, Project project) { PsiType type = psiParameter.getType(); if (!isEntityParameter(type, project)) { return; psiParameter, "Illegal parameter type (\'" + psiParameter.getType().getPresentableText() + "\'). Arrays or collections of entity types are not allowed.", LocalQuickFix.EMPTY_ARRAY); PsiModifierList modifierList = psiParameter.getModifierList(); PsiAnnotation annotation = modifierList.findAnnotation("javax.inject.Named"); if (annotation == null) {
@Override PsiElement resolveInternal(@NotNull String value, @NotNull PsiMethod mappingMethod) { PsiType relevantType = getRelevantType( mappingMethod ); if ( relevantType == null ) { return null; } PsiElement psiElement = resolveInternal( value, relevantType ); if ( psiElement != null ) { return psiElement; } return Stream.of( mappingMethod.getParameterList().getParameters() ) .filter( MapstructUtil::isMappingTarget ) .filter( psiParameter -> Objects.equals( psiParameter.getName(), value ) ) .findAny() .orElse( null ); }
PsiModifierList modifierList = parameter.getModifierList(); if (modifierList == null) { return; String annotationString = "@Named(\"" + parameter.getName() + "\")"; PsiAnnotation annotation = JavaPsiFacade.getElementFactory(project) modifierList.add(annotation); PsiFile file = parameter.getContainingFile(); if (file == null) { return;
@NotNull public static List<PsiTypeElement> getParameterTypeElements(@NotNull PsiParameter parameter) { PsiTypeElement typeElement = parameter.getTypeElement(); return typeElement != null && typeElement.getType() instanceof PsiDisjunctionType ? PsiTreeUtil.getChildrenOfTypeAsList(typeElement, PsiTypeElement.class) : Collections.singletonList(typeElement); }
@Override public boolean isVarArgs() { PsiParameter[] parameters = getParameterList().getParameters(); return parameters.length > 0 && parameters[parameters.length - 1].isVarArgs(); }
private static void collectSuperParameters(LinkedHashSet<PsiModifierListOwner> result, @NotNull PsiParameter parameter) { PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof PsiMethod)) { return; } PsiMethod method = (PsiMethod)scope; PsiElement parent = parameter.getParent(); if (!(parent instanceof PsiParameterList)) { return; } int index = ((PsiParameterList)parent).getParameterIndex(parameter); for (PsiMethod superMethod : getSuperAnnotationOwners(method)) { PsiParameter[] superParameters = superMethod.getParameterList().getParameters(); if (index < superParameters.length) { result.add(superParameters[index]); } } }
@Override public boolean processValues(PsiParameter t, ProcessingContext context, PairProcessor<PsiMethod, ProcessingContext> processor) { PsiElement scope = t.getDeclarationScope(); if (!(scope instanceof PsiMethod)) return true; return processor.process((PsiMethod)scope, context); }
PsiElement psiElement = psiParameter.getDeclarationScope(); if (psiElement instanceof PsiMethod) { if (!EndpointUtilities.isApiMethod((PsiMethod) psiElement)) { project = psiParameter.getContainingFile().getProject(); if (project == null) { return; LOG.error("Cannot determine project with parameter " + psiParameter.getText(), ex); return; PsiType psiType = psiParameter.getType(); if (!isApiParameter(psiType, project)) { return;
@Override PsiElement resolveInternal(@NotNull String value, @NotNull PsiMethod mappingMethod) { PsiParameter[] sourceParameters = MapstructUtil.getSourceParameters( mappingMethod ); if ( sourceParameters.length == 0 ) { return null; } if ( sourceParameters.length == 1 ) { PsiType parameterType = getParameterType( sourceParameters[0] ); PsiElement psiElement = parameterType == null ? null : resolveInternal( value, parameterType ); if ( psiElement != null ) { return psiElement; } } //TODO first do property mapping then parameter return Stream.of( sourceParameters ) .filter( psiParameter -> Objects.equals( psiParameter.getName(), value ) ) .findAny() .orElse( null ); }
@Nullable public static LinkedList<MethodConfig.Parameter> getParametersList(PsiParameter[] psiParameters) { if (psiParameters.length == 0) { return null; } LinkedList<MethodConfig.Parameter> parameters = new LinkedList<>(); for (PsiParameter psiParameter : psiParameters) { if (psiParameter.getTypeElement() == null || psiParameter.getName() == null) { continue; } parameters.add(new MethodConfig.Parameter(psiTypeToString(psiParameter.getTypeElement()), false)); } return parameters; }
@Override public boolean hasFormalParameterTypes() { PsiParameter[] parameters = getParameterList().getParameters(); for (PsiParameter parameter : parameters) { if (parameter.getTypeElement() == null) { return false; } } return true; } }
if (args.length < parms.length) return ApplicabilityLevel.VARARGS; PsiParameter lastParameter = parms[parms.length - 1]; if (!lastParameter.isVarArgs()) return ApplicabilityLevel.NOT_APPLICABLE; PsiType lastParmType = getParameterType(lastParameter, languageLevel, substitutorForMethod); if (!(lastParmType instanceof PsiArrayType)) return ApplicabilityLevel.NOT_APPLICABLE;
PsiElement scope = parameter.getDeclarationScope(); if (scope instanceof PsiMethod) { PsiMethod method = (PsiMethod)scope; PsiClass aClass = method.getContainingClass(); PsiElement parent = parameter.getParent(); if (aClass != null && parent instanceof PsiParameterList) { int index = ((PsiParameterList)parent).getParameterIndex(parameter);
public boolean accepts(@NotNull final PsiParameter t, final ProcessingContext context) { if (!super.accepts(t, context)) return false; final PsiMethod psiMethod = (PsiMethod)t.getDeclarationScope(); final PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); if (index < 0 || index >= parameters.length || !t.equals(parameters[index])) return false; return true; } });