@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); }
/** 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); }
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; }
public void addAnnotationWithParameterNameForMethodParameters(@NotNull PsiMethod method) { PsiParameterList parameterList = method.getParameterList(); if (null == parameterList) { return; } PsiParameter[] parameters = parameterList.getParameters(); for (PsiParameter param : parameters) { addAnnotationWithParameterName(param); } }
@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]); }
@NotNull @Override Object[] getVariantsInternal(@NotNull PsiMethod mappingMethod) { PsiClass sourceClass = getParameterClass( mappingMethod.getParameterList().getParameters()[0] ); if ( sourceClass == null || !sourceClass.isEnum() ) { return LookupElement.EMPTY_ARRAY; } return Stream.of( sourceClass.getFields() ) .filter( psiField -> psiField instanceof PsiEnumConstant ) .toArray( PsiField[]::new ); }
@Override public boolean hasFormalParameterTypes() { PsiParameter[] parameters = getParameterList().getParameters(); for (PsiParameter parameter : parameters) { if (parameter.getTypeElement() == null) { return false; } } return true; } }
@Override public boolean isVarArgs() { PsiParameter[] parameters = getParameterList().getParameters(); return parameters.length > 0 && parameters[parameters.length - 1].isVarArgs(); }
/** * Util function for extracting the type of the first parameter of a method. * * @param psiMethod the method to extract the parameter from * * @return the type of the first parameter of the method */ private static PsiType firstParameterPsiType(PsiMethod psiMethod) { return psiMethod.getParameterList().getParameters()[0].getType(); } }
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; } });
@Override protected String formatBody(final LookupElement lookup, final PsiMethod method) { final PsiParameterList parameterList = method.getParameterList(); final String parens = (parameterList.getParameters().length == 0) ? "()" : "("; return super.formatBody(lookup, method) + parens; }
@NotNull public static MethodConfig newMethodConfig(@NotNull PsiMethod psiMethod) { String classPatternString = getClassName(psiMethod); String methodPatternString = getMethodName(psiMethod); LinkedList<MethodConfig.Parameter> parameters = getParametersList(psiMethod.getParameterList().getParameters()); return new MethodConfig(classPatternString, methodPatternString, parameters == null ? new ArrayList<>() : parameters, true, false); }
public static void addElementForPsiParameter(@NotNull Project project, @NotNull CompletionResultSet result, @Nullable IdDomElement element) { if (null == element) { return; } for (PsiParameter parameter : JavaUtils.findMethod(project, element).get().getParameterList().getParameters()) { Optional<String> valueText = JavaUtils.getAnnotationValueText(parameter, Annotation.PARAM); if (valueText.isPresent()) { LookupElementBuilder builder = LookupElementBuilder.create(valueText.get()).withIcon(Icons.PARAM_COMPLETION_ICON); result.addElement(PrioritizedLookupElement.withPriority(builder, MybatisConstants.PRIORITY)); } } } }
private static PsiType[] getParameterTypes(PsiMethod method) { final PsiParameter[] parameters = method.getParameterList().getParameters(); final PsiType[] paramTypes = PsiType.createArray(parameters.length); for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = parameters[i].getType(); } return paramTypes; }
private static boolean specifiesLocale(@NonNull PsiMethod method) { PsiParameterList parameterList = method.getParameterList(); PsiParameter[] parameters = parameterList.getParameters(); for (PsiParameter parameter : parameters) { PsiType type = parameter.getType(); if (type.getCanonicalText().equals(LOCALE_CLS)) { return true; } } return false; } }
@NotNull @Override public List<String> getMethodTypes(NavigatablePsiElement method) { if (!(method instanceof PsiMethod)) return super.getMethodTypes(method); PsiMethod psiMethod = (PsiMethod)method; PsiType returnType = psiMethod.getReturnType(); List<String> strings = new ArrayList<>(); strings.add(returnType == null ? "" : returnType.getCanonicalText()); for (PsiParameter parameter : psiMethod.getParameterList().getParameters()) { PsiType type = parameter.getType(); boolean generic = type instanceof PsiClassType && ((PsiClassType)type).resolve() instanceof PsiTypeParameter; strings.add((generic ? "<" : "") + type.getCanonicalText(false) + (generic ? ">" : "")); strings.add(parameter.getName()); } return strings; }
private static boolean hasLooperConstructorParameter(@NonNull PsiClass cls) { for (PsiMethod constructor : cls.getConstructors()) { for (PsiParameter parameter : constructor.getParameterList().getParameters()) { PsiType type = parameter.getType(); if (LOOPER_CLS.equals(type.getCanonicalText())) { return true; } } } return false; } }
public static boolean isMainMethod(final PsiMethod method) { if (method == null || method.getContainingClass() == null) return false; if (PsiType.VOID != method.getReturnType()) return false; if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false; final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length != 1) return false; final PsiType type = parameters[0].getType(); if (!(type instanceof PsiArrayType)) return false; final PsiType componentType = ((PsiArrayType)type).getComponentType(); return componentType.equalsToText(CommonClassNames.JAVA_LANG_STRING); }
private static void checkMethod(@NonNull JavaContext context, @NonNull PsiMethod declaration, @NonNull PsiClass cls) { PsiParameter[] parameters = declaration.getParameterList().getParameters(); PsiParameter viewHolder = parameters[0]; PsiParameter parameter = parameters[1]; ParameterEscapesVisitor visitor = new ParameterEscapesVisitor(context, cls, parameter); declaration.accept(visitor); if (visitor.variableEscapes()) { reportError(context, viewHolder, parameter); } // Look for pending data binder calls that aren't executed before the method finishes List<PsiMethodCallExpression> dataBinderReferences = visitor.getDataBinders(); checkDataBinders(context, declaration, dataBinderReferences); }
void updateMethodMarker(PsiMethod psiMethod, MarkupModelEx markupModel) { DumbService.getInstance(myProject).runWhenSmart(() -> { removeInvalidMethods(markupModel); if (configuration.isMethodInstrumented(getClassName(psiMethod), getMethodName(psiMethod), getParametersTypesList(psiMethod.getParameterList().getParameters()))) { if (!hasIcon(psiMethod)) { setIcon(psiMethod, markupModel); } } else { removeIconIfPresent(psiMethod, markupModel); } }); }