@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); }
/** * Extract all valid source parameters from the provided {@code mappingMethod} * * @param mappingMethod the mapping method * * @return all source parameters from the provided {@code mappingMethod} */ @NotNull public static PsiParameter[] getSourceParameters(@NotNull PsiMethod mappingMethod) { if ( mappingMethod.getParameterList().getParametersCount() == 0 ) { return PsiParameter.EMPTY_ARRAY; } return Stream.of( mappingMethod.getParameterList().getParameters() ) .filter( MapstructUtil::isValidSourceParameter ) .toArray( PsiParameter[]::new ); }
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 accepts(@NotNull final PsiMethod method, final ProcessingContext context) { return method.getParameterList().getParametersCount() == paramCount; } });
Integer.MAX_VALUE, builder); builder.append(" "); builder.append(psiMethod.getParameterList().getParameterIndex((PsiParameter)owner));
setMethod.getParameterList().add(param); PsiUtil.setModifierProperty(setMethod, PsiModifier.PUBLIC, true); PsiUtil.setModifierProperty(setMethod, PsiModifier.STATIC, isStatic);
private static boolean isNotValueMapping(@Nullable PsiMethod mappingMethod) { return mappingMethod == null || mappingMethod.getParameterList().getParametersCount() != 1; } }
builder.append(psiMethod.getParameterList().getParameterIndex((PsiParameter)owner));
public static boolean isAllParameterWithAnnotation(@NotNull PsiMethod method, @NotNull Annotation annotation) { PsiParameter[] parameters = method.getParameterList().getParameters(); for (PsiParameter parameter : parameters) { if (!isAnnotationPresent(parameter, annotation)) { return false; } } return true; }
@Override public boolean accepts(@NotNull final PsiMethod psiMethod, final ProcessingContext context) { final PsiParameterList parameterList = psiMethod.getParameterList(); int dotsIndex = -1; while (++dotsIndex <types.length) { if (Comparing.equal("..", types[dotsIndex])) break; } if (dotsIndex == types.length && parameterList.getParametersCount() != dotsIndex || dotsIndex < types.length && parameterList.getParametersCount() < dotsIndex) { return false; } if (dotsIndex > 0) { final PsiParameter[] psiParameters = parameterList.getParameters(); for (int i = 0; i < dotsIndex; i++) { if (!Comparing.equal("?", types[i]) && !typeEquivalent(psiParameters[i].getType(), types[i])) { return false; } } } return true; }
public static boolean isGetter(@NotNull PsiMethod method) { if ( method.getParameterList().getParametersCount() != 0 ) { return false; } //TODO if we can use the AccessorNamingStrategy it would be awesome String methodName = method.getName(); return ( methodName.startsWith( "get" ) && !methodName.equals( "getClass" )) || methodName.startsWith( "is" ); }
PsiElement parent = parameter.getParent(); if (aClass != null && parent instanceof PsiParameterList) { int index = ((PsiParameterList)parent).getParameterIndex(parameter); HierarchicalMethodSignature methodSignature = method.getHierarchicalMethodSignature(); if (!visited.add(superMethod)) continue; if (!resolveHelper.isAccessible(superMethod, owner, null)) continue; PsiParameter[] superParameters = superMethod.getParameterList().getParameters(); if (index < superParameters.length) { annotations = ArrayUtil.mergeArrays(annotations, getAllAnnotations(superParameters[index], inHierarchy, visited));
LocalVariableBinding binding = parameter.getVariableBinding(); if (parent instanceof PsiParameterList && binding != null) { int index = ((PsiParameterList) parent).getParameterIndex(parameter); MethodBinding enclosingMethod = binding.getEnclosingMethod(); if (enclosingMethod != null) { MethodBinding enclosingMethod = method.getBinding(); if (parent instanceof PsiParameterList) { int index = ((PsiParameterList) parent).getParameterIndex(parameter); if (index != -1) { annotations = repository.getParameterAnnotations(enclosingMethod, index);
public void addAnnotationWithParameterNameForMethodParameters(@NotNull PsiMethod method) { PsiParameterList parameterList = method.getParameterList(); if (null == parameterList) { return; } PsiParameter[] parameters = parameterList.getParameters(); for (PsiParameter param : parameters) { addAnnotationWithParameterName(param); } }
private static boolean acceptsMethod(PsiElementFactory elementFactory, PsiMethod method, int paramCount, String... paramTypes) { PsiParameterList parameterList = method.getParameterList(); if (paramCount >= 0 && paramCount != parameterList.getParametersCount()) return false; if (paramTypes.length == 0) return true; if (parameterList.getParametersCount() < paramTypes.length) return false; PsiParameter[] psiParameters = parameterList.getParameters(); for (int i = 0; i < paramTypes.length; i++) { String paramType = paramTypes[i]; PsiParameter parameter = psiParameters[i]; PsiType psiType = parameter.getType(); if (acceptsName(paramType, psiType.getCanonicalText())) continue; try { if (psiType.isAssignableFrom(elementFactory.createTypeFromText(paramType, parameter))) continue; } catch (IncorrectOperationException ignored) { } return false; } return true; }
public static boolean isSetter(@NotNull PsiMethod method) { if ( method.getParameterList().getParametersCount() != 1 ) { return false; } //TODO if we can use the AccessorNamingStrategy it would be awesome String methodName = method.getName(); return methodName.startsWith( "set" ); }
return getDirectAnnotations(owner); index = ((PsiParameterList)parameter.getParent()).getParameterIndex(parameter); AbstractMethodDeclaration declaration = (AbstractMethodDeclaration) psiMethod.getNativeNode(); assert declaration != null; PsiParameter[] parameters = methodElement.getParameterList().getParameters(); if (index < parameters.length) { PsiModifierList parameterModifiers = parameters[index].getModifierList();
.getParameterIndex(argExpression); if (paramIndex < 0) { return;
@NotNull @Override public List<String> getParameterAnnotations(@Nullable NavigatablePsiElement method, int paramIndex) { if (!(method instanceof PsiMethod)) return super.getParameterAnnotations(method, paramIndex); PsiMethod psiMethod = (PsiMethod)method; PsiParameter[] parameters = psiMethod.getParameterList().getParameters(); if (paramIndex < 0 || paramIndex >= parameters.length) return Collections.emptyList(); return getAnnotationsInner(parameters[paramIndex]); }
/** Returns true if the given type matches the given fully qualified type name */ public boolean parameterHasType( @Nullable PsiMethod method, int parameterIndex, @NonNull String typeName) { if (method == null) { return false; } PsiParameterList parameterList = method.getParameterList(); return parameterList.getParametersCount() > parameterIndex && typeMatches(parameterList.getParameters()[parameterIndex].getType(), typeName); }