@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); }
@Nullable @Override public PsiType getCatchType() { return mParameter.getType(); }
private static PsiType getNormalizedType(PsiParameter parameter) { final PsiType type = parameter.getType(); if (type instanceof PsiEllipsisType) { return ((PsiEllipsisType)type).getComponentType(); } return type; }
private static PsiType getParameterType(@NotNull final PsiParameter parameter, @NotNull LanguageLevel languageLevel, @NotNull final PsiSubstitutor substitutor) { PsiType parmType = parameter.getType(); if (parmType instanceof PsiClassType) { parmType = ((PsiClassType)parmType).setLanguageLevel(languageLevel); } return substitutor.substitute(parmType); }
@Nullable @Override PsiType resolvedType() { PsiElement element = resolve(); if ( element instanceof PsiMethod ) { return ( (PsiMethod) element ).getReturnType(); } else if ( element instanceof PsiParameter ) { return ( (PsiParameter) element ).getType(); } return null; }
@Nullable @Override PsiType resolvedType() { PsiElement element = resolve(); if ( element instanceof PsiMethod ) { return firstParameterPsiType( (PsiMethod) element ); } else if ( element instanceof PsiParameter ) { return ( (PsiParameter) element ).getType(); } return null; }
/** * 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 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(); }
@Nullable public static PsiMethod findPropertySetterWithType(String propertyName, boolean isStatic, PsiType type, Iterator<PsiMethod> methods) { while (methods.hasNext()) { PsiMethod method = methods.next(); if (method.hasModifierProperty(PsiModifier.STATIC) != isStatic) continue; if (isSimplePropertySetter(method)) { if (getPropertyNameBySetter(method).equals(propertyName)) { PsiType methodType = method.getParameterList().getParameters()[0].getType(); if (type.equals(methodType)) return method; } } } return null; }
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; } }
protected MethodSignatureBase(@NotNull PsiSubstitutor substitutor, @Nullable PsiParameterList parameterList, @Nullable PsiTypeParameterList typeParameterList) { mySubstitutor = substitutor; if (parameterList == null) { myParameterTypes = PsiType.EMPTY_ARRAY; } else { final PsiParameter[] parameters = parameterList.getParameters(); myParameterTypes = PsiType.createArray(parameters.length); for (int i = 0; i < parameters.length; i++) { PsiType type = parameters[i].getType(); if (type instanceof PsiEllipsisType) type = ((PsiEllipsisType)type).toArrayType(); myParameterTypes[i] = substitutor.substitute(type); } } myTypeParameters = typeParameterList == null ? PsiTypeParameter.EMPTY_ARRAY : typeParameterList.getTypeParameters(); }
@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; } }
@Nullable public static PsiType getPropertyType(final PsiMember member) { if (member instanceof PsiField) { return ((PsiField)member).getType(); } else if (member instanceof PsiMethod) { final PsiMethod psiMethod = (PsiMethod)member; if (isSimplePropertyGetter(psiMethod)) { return psiMethod.getReturnType(); } else if (isSimplePropertySetter(psiMethod)) { return psiMethod.getParameterList().getParameters()[0].getType(); } } return null; }
public void testTargetPropertyReferencesTargetParameter() { myFixture.configureByFile( "TargetPropertyReferencesTargetParameter.java" ); PsiElement reference = myFixture.getElementAtCaret(); assertThat( reference ) .isInstanceOfSatisfying( PsiParameter.class, parameter -> { assertThat( parameter.getName() ).isEqualTo( "target" ); assertThat( parameter.getType().getPresentableText() ).isEqualTo( "CarDto" ); PsiMethod mappingMethod = PsiTreeUtil.getParentOfType( parameter, PsiMethod.class ); assertThat( mappingMethod ).isNotNull(); assertThat( mappingMethod.getName() ).isEqualTo( "update" ); assertThat( mappingMethod.getReturnType() ).isNotNull(); assertThat( mappingMethod.getReturnType().getPresentableText() ).isEqualTo( "void" ); } ); }
/** 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 void testSourcePropertyReferencesSourceParameter() { myFixture.configureByFile( "SourcePropertyReferencesSourceParameter.java" ); PsiElement reference = myFixture.getElementAtCaret(); assertThat( reference ) .isInstanceOfSatisfying( PsiParameter.class, parameter -> { assertThat( parameter.getName() ).isEqualTo( "source" ); assertThat( parameter.getType().getPresentableText() ).isEqualTo( "Car" ); PsiMethod mappingMethod = PsiTreeUtil.getParentOfType( parameter, PsiMethod.class ); assertThat( mappingMethod ).isNotNull(); assertThat( mappingMethod.getName() ).isEqualTo( "map" ); assertThat( mappingMethod.getReturnType() ).isNotNull(); assertThat( mappingMethod.getReturnType().getPresentableText() ).isEqualTo( "CarDto" ); } ); }
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); }