public void testCreateConfiguration() throws IOException, ExecutionException { Module module1 = getModule1(); PsiClass psiClass = findTestA(module1); JUnitConfiguration configuration = createConfiguration(psiClass); assertEquals( Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules())); checkClassName(psiClass.getQualifiedName(), configuration); assertEquals(psiClass.getName(), configuration.getName()); checkTestObject(JUnitConfiguration.TEST_CLASS, configuration); Module module2 = getModule2(); Assertion.compareUnordered(new Module[] {module1, module2}, configuration.getValidModules()); PsiClass innerTest = findClass(module1, INNER_TEST_NAME); configuration = createJUnitConfiguration( innerTest, TestClassConfigurationProducer.class, new MapDataContext()); checkClassName(RT_INNER_TEST_NAME, configuration); checkCanRun(configuration); PsiMethod[] testMethod = innerTest.findMethodsByName("test", false); assertEquals(1, testMethod.length); configuration = createConfiguration(testMethod[0]); checkClassName(RT_INNER_TEST_NAME, configuration); checkMethodName("test", configuration); checkTestObject(JUnitConfiguration.TEST_METHOD, configuration); checkCanRun(configuration); PsiMethod mainMethod = innerTest.findMethodsByName("main", false)[0]; ApplicationConfiguration appConfiguration = createConfiguration(mainMethod); assertEquals(RT_INNER_TEST_NAME, appConfiguration.MAIN_CLASS_NAME); checkCanRun(configuration); }
@NotNull private static List<PsiMethod> findMethodsBySignature( @NotNull PsiClass aClass, @NotNull PsiMethod patternMethod, boolean checkBases, boolean stopOnFirst) { final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases); if (methodsByName.length == 0) return Collections.emptyList(); final List<PsiMethod> methods = new SmartList<PsiMethod>(); final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY); for (final PsiMethod method : methodsByName) { final PsiClass superClass = method.getContainingClass(); final PsiSubstitutor substitutor; if (checkBases && !aClass.equals(superClass)) { substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); } else { substitutor = PsiSubstitutor.EMPTY; } final MethodSignature signature = method.getSignature(substitutor); if (signature.equals(patternSignature)) { methods.add(method); if (stopOnFirst) { break; } } } return methods; }
@Nullable private static String computeConstantReturnValue(PsiClass languagePsiClass, String methodName) { final PsiMethod[] methods = languagePsiClass.findMethodsByName(methodName, false); if (methods.length != 1) { return null; } return getStringConstantExpression(methods[0]); }
private static boolean areMissingMethodsDeclared(GrReferenceExpression ref) { PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref); if (!(qualifierType instanceof PsiClassType)) return false; PsiClass resolved = ((PsiClassType) qualifierType).resolve(); if (resolved == null) return false; if (ref.getParent() instanceof GrCall) { PsiMethod[] found = resolved.findMethodsByName("methodMissing", true); for (PsiMethod method : found) { if (MissingMethodAndPropertyUtil.isMethodMissing(method)) return true; } } else { PsiMethod[] found = resolved.findMethodsByName("propertyMissing", true); for (PsiMethod method : found) { if (MissingMethodAndPropertyUtil.isPropertyMissing(method)) return true; } } return false; }
@Nullable private PsiType extractListTypeFromContainingClass(PsiElement element) { PsiClass listClass = PsiTreeUtil.getParentOfType(element, PsiClass.class); if (listClass == null) { return null; } final PsiMethod[] getMethods = listClass.findMethodsByName("get", true); if (getMethods.length == 0) { return null; } final PsiType type = getMethods[0].getReturnType(); if (!(type instanceof PsiClassType)) { return null; } final PsiClassType classType = (PsiClassType) type; final PsiClass parameterClass = classType.resolve(); if (parameterClass == null) { return null; } PsiClass subClass = null; while (listClass != null && !listClass.hasTypeParameters()) { subClass = listClass; listClass = listClass.getSuperClass(); } if (listClass == null || subClass == null) { return TypeUtils.getObjectType(element); } final PsiTypeParameter[] typeParameters = listClass.getTypeParameters(); if (!parameterClass.equals(typeParameters[0])) { return TypeUtils.getObjectType(element); } final PsiReferenceList extendsList = subClass.getExtendsList(); if (extendsList == null) { return null; } final PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements(); if (referenceElements.length == 0) { return null; } final PsiType[] types = referenceElements[0].getTypeParameters(); if (types.length == 0) { return TypeUtils.getObjectType(element); } return types[0]; }
private boolean hasGoodToString(PsiClass aClass) { final PsiMethod[] methods = aClass.findMethodsByName(HardcodedMethodConstants.TO_STRING, true); for (PsiMethod method : methods) { final PsiClass containingClass = method.getContainingClass(); if (containingClass == null) { continue; } final String name = containingClass.getQualifiedName(); if (CommonClassNames.JAVA_LANG_OBJECT.equals(name)) { continue; } final PsiParameterList parameterList = method.getParameterList(); if (parameterList.getParametersCount() == 0) { return true; } } return false; }
@NotNull public static List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName( @NotNull PsiClass psiClass, String name, boolean checkBases) { if (!checkBases) { final PsiMethod[] methodsByName = psiClass.findMethodsByName(name, false); final List<Pair<PsiMethod, PsiSubstitutor>> ret = new ArrayList<Pair<PsiMethod, PsiSubstitutor>>(methodsByName.length); for (final PsiMethod method : methodsByName) { ret.add(new Pair<PsiMethod, PsiSubstitutor>(method, PsiSubstitutor.EMPTY)); } return ret; } Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map = getMap(psiClass, MemberType.METHOD); @SuppressWarnings("unchecked") List<Pair<PsiMethod, PsiSubstitutor>> list = (List) map.get(name); return list == null ? Collections.<Pair<PsiMethod, PsiSubstitutor>>emptyList() : Collections.unmodifiableList(list); }
private static boolean areGroovyObjectMethodsOverridden(GrReferenceExpression ref) { PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref); if (!(qualifierType instanceof PsiClassType)) return false; PsiClass resolved = ((PsiClassType) qualifierType).resolve(); if (resolved == null) return false; PsiClass groovyObject = JavaPsiFacade.getInstance(ref.getProject()) .findClass(GroovyCommonClassNames.GROOVY_OBJECT, ref.getResolveScope()); if (groovyObject == null) return false; String methodName; if (ref.getParent() instanceof GrCall) { methodName = "invokeMethod"; } else if (PsiUtil.isLValue(ref)) { methodName = "setProperty"; } else { methodName = "getProperty"; } PsiMethod[] patternMethods = groovyObject.findMethodsByName(methodName, false); if (patternMethods.length != 1) return false; PsiMethod patternMethod = patternMethods[0]; PsiMethod found = resolved.findMethodBySignature(patternMethod, true); if (found == null) return false; PsiClass aClass = found.getContainingClass(); if (aClass == null) return false; String qname = aClass.getQualifiedName(); if (GroovyCommonClassNames.GROOVY_OBJECT.equals(qname)) return false; if (GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(qname)) return false; return true; }
public static void prepareWizardData(final WizardData data, PsiClass boundClass) throws MyException { final PsiMethod[] allGetDataMethods = boundClass.findMethodsByName("getData", false); final PsiMethod[] allSetDataMethods = boundClass.findMethodsByName("setData", false); PsiMethod setDataMethod = null; PsiClass beanClass = null; // find get/set pair and bean class outer: for (int i = 0; i < allGetDataMethods.length; i++) { final PsiMethod _getMethod = allGetDataMethods[i]; if (_getMethod.getReturnType() != PsiType.VOID) { continue; } final PsiParameter[] _getMethodParameters = _getMethod.getParameterList().getParameters(); if (_getMethodParameters.length != 1) { continue; } final PsiClass _getParameterClass = getClassByType(_getMethodParameters[0].getType()); if (_getParameterClass == null) { continue; } for (final PsiMethod _setMethod : allSetDataMethods) { if (_setMethod.getReturnType() != PsiType.VOID) { continue; } final PsiParameter[] _setMethodParameters = _setMethod.getParameterList().getParameters(); if (_setMethodParameters.length != 1) { continue; } final PsiClass _setParameterClass = getClassByType(_setMethodParameters[0].getType()); if (_setParameterClass != _getParameterClass) { continue; } // pair found !!! setDataMethod = _setMethod; beanClass = _getParameterClass; break outer; } } if (beanClass == null) { // nothing found return; } data.myBindToNewBean = false; data.myBeanClass = beanClass; // parse setData() and try to associate fields with bean { final PsiCodeBlock body = setDataMethod.getBody(); if (body == null) { return; } final PsiElement[] children = body.getChildren(); for (PsiElement child : children) { // Parses sequences like: a.foo(b.bar()); final PsiField bindingField; if (!(child instanceof PsiExpressionStatement)) { continue; } final PsiExpression expression = ((PsiExpressionStatement) child).getExpression(); if (!(expression instanceof PsiMethodCallExpression)) { continue; } final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) expression; // find binding field ('a') int index = -1; { final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression); if (!(psiElement instanceof PsiField)) { continue; } if (((PsiField) psiElement).getContainingClass() != boundClass) { continue; } bindingField = (PsiField) psiElement; // find binding for this field final FormProperty2BeanProperty[] bindings = data.myBindings; for (int j = 0; j < bindings.length; j++) { final FormProperty2BeanProperty binding = bindings[j]; if (bindingField .getName() .equals(binding.myFormProperty.getLwComponent().getBinding())) { index = j; break; } } } if (index == -1) { continue; } // find 'bar()' { final PsiReferenceParameterList parameterList = callExpression.getMethodExpression().getParameterList(); if (parameterList == null) { continue; } final PsiExpressionList argumentList = callExpression.getArgumentList(); if (argumentList == null) { continue; } final PsiExpression[] expressions = argumentList.getExpressions(); if (expressions == null || expressions.length != 1) { continue; } if (!(expressions[0] instanceof PsiMethodCallExpression)) { continue; } final PsiMethodCallExpression callExpression2 = ((PsiMethodCallExpression) expressions[0]); // check that 'b' is parameter final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression2); if (!(psiElement instanceof PsiParameter)) { continue; } final PsiMethod barMethod = ((PsiMethod) callExpression2.getMethodExpression().resolve()); if (barMethod == null) { continue; } if (!PropertyUtil.isSimplePropertyGetter(barMethod)) { continue; } final String propertyName = PropertyUtil.getPropertyName(barMethod); // There are two possible types: boolean and java.lang.String String typeName = barMethod.getReturnType().getCanonicalText(); if (!"boolean".equals(typeName) && !"java.lang.String".equals(typeName)) { continue; } data.myBindings[index].myBeanProperty = new BeanProperty(propertyName, typeName); } } } }
private static boolean processDeclarationsInClassNotCached( @NotNull PsiClass aClass, @NotNull PsiScopeProcessor processor, @NotNull ResolveState state, @Nullable Set<PsiClass> visited, PsiElement last, @NotNull PsiElement place, boolean isRaw, @NotNull LanguageLevel languageLevel) { if (visited == null) visited = new THashSet<PsiClass>(); if (!visited.add(aClass)) return true; processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass); final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY); final NameHint nameHint = processor.getHint(NameHint.KEY); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) { if (nameHint != null) { final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false); if (fieldByName != null && !processor.execute(fieldByName, state)) return false; } else { final PsiField[] fields = aClass.getFields(); for (final PsiField field : fields) { if (!processor.execute(field, state)) return false; } } } PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) { PsiSubstitutor baseSubstitutor = state.get(PsiSubstitutor.KEY); final PsiMethod[] methods = nameHint != null ? aClass.findMethodsByName(nameHint.getName(state), false) : aClass.getMethods(); for (final PsiMethod method : methods) { PsiSubstitutor finalSubstitutor = checkRaw(isRaw, factory, method, baseSubstitutor); ResolveState methodState = finalSubstitutor == baseSubstitutor ? state : state.put(PsiSubstitutor.KEY, finalSubstitutor); if (!processor.execute(method, methodState)) return false; } } if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) { if (last != null && last.getParent() == aClass) { // Parameters final PsiTypeParameterList list = aClass.getTypeParameterList(); if (list != null && !list.processDeclarations(processor, ResolveState.initial(), last, place)) return false; } if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) { // Inners if (nameHint != null) { final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false); if (inner != null) { if (!processor.execute(inner, state)) return false; } } else { final PsiClass[] inners = aClass.getInnerClasses(); for (final PsiClass inner : inners) { if (!processor.execute(inner, state)) return false; } } } } return last instanceof PsiReferenceList || processSuperTypes( aClass, processor, visited, last, place, state, isRaw, factory, languageLevel); }