@Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); if (referenceFound) { return; } final String text = reference.getText(); if (text.indexOf((int) '.') >= 0 || !name.equals(text)) { return; } final PsiElement element = reference.resolve(); if (!(element instanceof PsiClass) || element instanceof PsiTypeParameter) { return; } final PsiClass aClass = (PsiClass) element; final String testClassName = aClass.getName(); final String testClassQualifiedName = aClass.getQualifiedName(); if (testClassQualifiedName == null || testClassName == null || testClassQualifiedName.equals(fullyQualifiedName) || !testClassName.equals(name)) { return; } referenceFound = true; }
private static boolean isAnnotated(ASTNode element) { PsiJavaCodeReferenceElement ref = (PsiJavaCodeReferenceElement) element.getPsi(); PsiElement qualifier = ref.getQualifier(); if (qualifier instanceof PsiJavaCodeReferenceElement) { if (((PsiJavaCodeReferenceElement) qualifier).resolve() instanceof PsiPackage) { return false; } if (PsiTreeUtil.getChildOfType(qualifier, PsiAnnotation.class) != null) { return true; } } PsiModifierList modifierList = PsiImplUtil.findNeighbourModifierList(ref); if (modifierList != null) { for (PsiAnnotation annotation : modifierList.getAnnotations()) { if (PsiImplUtil.findApplicableTarget(annotation, PsiAnnotation.TargetType.TYPE_USE) != null) { return true; } } } return false; }
@Override protected void invokeImpl(final PsiClass targetClass) { PsiNewExpression newExpression = getNewExpression(); PsiJavaCodeReferenceElement ref = newExpression.getClassOrAnonymousClassReference(); assert ref != null; String refName = ref.getReferenceName(); LOG.assertTrue(refName != null); PsiElementFactory elementFactory = JavaPsiFacade.getInstance(newExpression.getProject()).getElementFactory(); PsiClass created = elementFactory.createClass(refName); final PsiModifierList modifierList = created.getModifierList(); LOG.assertTrue(modifierList != null); if (PsiTreeUtil.isAncestor(targetClass, newExpression, true)) { if (targetClass.isInterface()) { modifierList.setModifierProperty(PsiModifier.PACKAGE_LOCAL, true); } else { modifierList.setModifierProperty(PsiModifier.PRIVATE, true); } } if (!PsiTreeUtil.isAncestor(targetClass, newExpression, true) || PsiUtil.getEnclosingStaticElement(newExpression, targetClass) != null || isInThisOrSuperCall(newExpression)) { modifierList.setModifierProperty(PsiModifier.STATIC, true); } created = (PsiClass) targetClass.add(created); setupClassFromNewExpression(created, newExpression); setupGenericParameters(created, ref); }
private static Set<LookupElement> suggestQualifierItems( CompletionParameters parameters, PsiJavaCodeReferenceElement qualifier, ElementFilter filter) { String referenceName = qualifier.getReferenceName(); if (referenceName == null) { return Collections.emptySet(); } PrefixMatcher qMatcher = new CamelHumpMatcher(referenceName); Set<LookupElement> plainVariants = JavaSmartCompletionContributor.completeReference( qualifier, qualifier, filter, true, true, parameters, qMatcher); for (PsiClass aClass : PsiShortNamesCache.getInstance(qualifier.getProject()) .getClassesByName(referenceName, qualifier.getResolveScope())) { plainVariants.add(JavaClassNameCompletionContributor.createClassLookupItem(aClass, true)); } if (!plainVariants.isEmpty()) { return plainVariants; } final Set<LookupElement> allClasses = new LinkedHashSet<LookupElement>(); PsiElement qualifierName = qualifier.getReferenceNameElement(); if (qualifierName != null) { JavaClassNameCompletionContributor.addAllClasses( parameters.withPosition(qualifierName, qualifierName.getTextRange().getEndOffset()), true, qMatcher, new CollectConsumer<LookupElement>(allClasses)); } return allClasses; }
@Override public void visitAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) { if (anonymousClass instanceof PsiEnumConstantInitializer) { return; } final PsiMember containingMember = PsiTreeUtil.getParentOfType(anonymousClass, PsiMember.class); if (containingMember == null || containingMember.hasModifierProperty(PsiModifier.STATIC)) { return; } final PsiJavaCodeReferenceElement reference = anonymousClass.getBaseClassReference(); if (reference.resolve() == null) { // don't warn on broken code return; } final PsiClass containingClass = PsiTreeUtil.getParentOfType(anonymousClass, PsiClass.class); if (containingClass == null) { return; } if (containingClass.getContainingClass() != null && !containingClass.hasModifierProperty(PsiModifier.STATIC)) { // strictly speaking can be named static inner class but not when part of the current // containing class return; } final InnerClassReferenceVisitor visitor = new InnerClassReferenceVisitor(anonymousClass); anonymousClass.accept(visitor); if (!visitor.canInnerClassBeStatic()) { return; } if (hasReferenceToLocalClass(anonymousClass)) { return; } registerClassError(anonymousClass); }
@Nullable private ProblemDescriptor[] checkMember( final PsiDocCommentOwner docCommentOwner, final InspectionManager manager, final boolean isOnTheFly) { final ArrayList<ProblemDescriptor> problems = new ArrayList<ProblemDescriptor>(); final PsiDocComment docComment = docCommentOwner.getDocComment(); if (docComment == null) return null; final Set<PsiJavaCodeReferenceElement> references = new HashSet<PsiJavaCodeReferenceElement>(); docComment.accept(getVisitor(references, docCommentOwner, problems, manager, isOnTheFly)); for (PsiJavaCodeReferenceElement reference : references) { final List<PsiClass> classesToImport = new ImportClassFix(reference).getClassesToImport(); final PsiElement referenceNameElement = reference.getReferenceNameElement(); problems.add( manager.createProblemDescriptor( referenceNameElement != null ? referenceNameElement : reference, cannotResolveSymbolMessage("<code>" + reference.getText() + "</code>"), !isOnTheFly || classesToImport.isEmpty() ? null : new AddImportFix(classesToImport), ProblemHighlightType.LIKE_UNKNOWN_SYMBOL, isOnTheFly)); } return problems.isEmpty() ? null : problems.toArray(new ProblemDescriptor[problems.size()]); }
private void fixReferencesToStatic(PsiElement classMember) throws IncorrectOperationException { final StaticReferencesCollector collector = new StaticReferencesCollector(); classMember.accept(collector); ArrayList<PsiJavaCodeReferenceElement> refs = collector.getReferences(); ArrayList<PsiElement> members = collector.getReferees(); ArrayList<PsiClass> classes = collector.getRefereeClasses(); PsiElementFactory factory = JavaPsiFacade.getInstance(classMember.getProject()).getElementFactory(); for (int i = 0; i < refs.size(); i++) { PsiJavaCodeReferenceElement ref = refs.get(i); PsiElement namedElement = members.get(i); PsiClass aClass = classes.get(i); if (namedElement instanceof PsiNamedElement) { PsiReferenceExpression newRef = (PsiReferenceExpression) factory.createExpressionFromText( "a." + ((PsiNamedElement) namedElement).getName(), null); PsiExpression qualifierExpression = newRef.getQualifierExpression(); assert qualifierExpression != null; qualifierExpression = (PsiExpression) qualifierExpression.replace(factory.createReferenceExpression(aClass)); qualifierExpression.putCopyableUserData(PRESERVE_QUALIFIER, ref.isQualified()); ref.replace(newRef); } } }
private static String buildAnnotationText(PsiAnnotation annotation) { final StringBuilder out = new StringBuilder("@"); final PsiJavaCodeReferenceElement nameReferenceElement = annotation.getNameReferenceElement(); assert nameReferenceElement != null; out.append(nameReferenceElement.getText()); final PsiAnnotationParameterList parameterList = annotation.getParameterList(); final PsiNameValuePair[] attributes = parameterList.getAttributes(); if (attributes.length == 0) { return out.toString(); } out.append('('); if (attributes.length == 1) { final PsiNameValuePair attribute = attributes[0]; @NonNls final String name = attribute.getName(); if (name != null && !PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME.equals(name)) { out.append(name).append('='); } buildAttributeValueText(attribute.getValue(), out); } else { for (int i = 0; i < attributes.length; i++) { final PsiNameValuePair attribute = attributes[i]; if (i > 0) { out.append(','); } out.append(attribute.getName()).append('='); buildAttributeValueText(attribute.getValue(), out); } } out.append(')'); return out.toString(); }
public InspectionGadgetsFix buildFix(Object... infos) { final PsiNewExpression expression = (PsiNewExpression) infos[0]; final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); assert classReference != null; final String className = classReference.getText(); return new CachedNumberConstructorCallFix(className); }
private void findUsagesForStaticMethod(PsiMethod method, List<FixableUsageInfo> usages) { final PsiManager psiManager = method.getManager(); final Project project = psiManager.getProject(); final GlobalSearchScope scope = GlobalSearchScope.allScope(project); final Iterable<PsiReference> calls = ReferencesSearch.search(method, scope); final String fullyQualifiedName = getQualifiedName(); for (PsiReference reference : calls) { final PsiElement referenceElement = reference.getElement(); final PsiElement parent = referenceElement.getParent(); if (parent instanceof PsiMethodCallExpression) { final PsiMethodCallExpression call = (PsiMethodCallExpression) parent; if (!isInMovedElement(call)) { usages.add(new RetargetStaticMethodCall(call, fullyQualifiedName)); } } else if (parent instanceof PsiImportStaticStatement) { final PsiJavaCodeReferenceElement importReference = ((PsiImportStaticStatement) parent).getImportReference(); if (importReference != null) { final PsiElement qualifier = importReference.getQualifier(); if (qualifier instanceof PsiJavaCodeReferenceElement) { usages.add( new ReplaceClassReference( (PsiJavaCodeReferenceElement) qualifier, fullyQualifiedName)); } } } } usages.add(new RemoveMethod(method)); }
private static boolean shouldInsertParentheses(PsiClass psiClass, PsiElement position) { final PsiJavaCodeReferenceElement ref = PsiTreeUtil.getParentOfType(position, PsiJavaCodeReferenceElement.class); if (ref == null) { return false; } final PsiReferenceParameterList parameterList = ref.getParameterList(); if (parameterList != null && parameterList.getTextLength() > 0) { return false; } final PsiElement prevElement = FilterPositionUtil.searchNonSpaceNonCommentBack(ref); if (prevElement != null && prevElement.getParent() instanceof PsiNewExpression) { Set<PsiType> expectedTypes = new HashSet<PsiType>(); for (ExpectedTypeInfo info : ExpectedTypesProvider.getExpectedTypes((PsiExpression) prevElement.getParent(), true)) { expectedTypes.add(info.getType()); } return JavaCompletionUtil.isDefinitelyExpected(psiClass, expectedTypes, position); } return false; }
@Override public void visitNewExpression(PsiNewExpression expression) { super.visitNewExpression(expression); final PsiJavaCodeReferenceElement classReference = expression.getClassReference(); if (classReference == null) { return; } final String name = classReference.getReferenceName(); if (!"BigDecimal".equals(name)) { return; } final PsiMethod constructor = expression.resolveConstructor(); if (constructor == null) { return; } final PsiParameterList parameterList = constructor.getParameterList(); final int length = parameterList.getParametersCount(); if (length != 1 && length != 2) { return; } final PsiParameter[] parameters = parameterList.getParameters(); final PsiParameter firstParameter = parameters[0]; final PsiType type = firstParameter.getType(); if (type != PsiType.DOUBLE) { return; } registerNewExpressionError(expression); }
@Nullable static Pair<PsiClass, Integer> getTypeParameterInfo(PsiElement context) { final PsiReferenceParameterList parameterList = PsiTreeUtil.getContextOfType(context, PsiReferenceParameterList.class, true); if (parameterList == null) return null; PsiElement parent = parameterList.getParent(); if (!(parent instanceof PsiJavaCodeReferenceElement)) return null; final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) parent; final int parameterIndex; int index = 0; final PsiTypeElement typeElement = PsiTreeUtil.getContextOfType(context, PsiTypeElement.class, true); if (typeElement != null) { final PsiTypeElement[] elements = referenceElement.getParameterList().getTypeParameterElements(); while (index < elements.length) { final PsiTypeElement element = elements[index++]; if (element == typeElement) break; } } parameterIndex = index - 1; if (parameterIndex < 0) return null; final PsiElement target = referenceElement.resolve(); if (!(target instanceof PsiClass)) return null; final PsiClass referencedClass = (PsiClass) target; final PsiTypeParameter[] typeParameters = referencedClass.getTypeParameters(); if (typeParameters.length <= parameterIndex) return null; return Pair.create(referencedClass, parameterIndex); }
/** * The parameter <code>allowIndirect</code> determines if the method should look for indirect * annotations, i.e. annotations which have themselves been annotated by the supplied annotation * name. Currently, this only allows one level of indirection and returns an array of * [base-annotation, indirect annotation] * * <p>The <code>annotationName</code> parameter is a pair of the target annotation class' fully * qualified name as a String and as a Set. This is done for performance reasons because the Set * is required by the {@link com.intellij.codeInsight.AnnotationUtil} utility class and allows to * avoid unnecessary object constructions. */ public static PsiAnnotation[] getAnnotationsFromImpl( PsiModifierListOwner owner, Pair<String, ? extends Set<String>> annotationName, boolean allowIndirect, boolean inHierarchy) { final PsiAnnotation directAnnotation = inHierarchy ? AnnotationUtil.findAnnotationInHierarchy(owner, annotationName.second) : AnnotationUtil.findAnnotation(owner, annotationName.second); if (directAnnotation != null) { return new PsiAnnotation[] {directAnnotation}; } if (allowIndirect) { final PsiAnnotation[] annotations = getAnnotations(owner, inHierarchy); for (PsiAnnotation annotation : annotations) { PsiJavaCodeReferenceElement nameReference = annotation.getNameReferenceElement(); if (nameReference == null) continue; PsiElement resolved = nameReference.resolve(); if (resolved instanceof PsiClass) { final PsiAnnotation psiAnnotation = AnnotationUtil.findAnnotationInHierarchy( (PsiModifierListOwner) resolved, annotationName.second); if (psiAnnotation != null) { return new PsiAnnotation[] {psiAnnotation, annotation}; } } } } return PsiAnnotation.EMPTY_ARRAY; }
private static void checkMethodReference( PsiMethodReferenceExpression expression, InspectionManager inspectionManager, List<ProblemDescriptor> problems) { final PsiTypeElement qualifierTypeElement = expression.getQualifierType(); if (qualifierTypeElement != null) { final PsiType psiType = qualifierTypeElement.getType(); if (psiType instanceof PsiClassType && !(((PsiClassType) psiType).isRaw())) { final JavaResolveResult result = expression.advancedResolve(false); final PsiElement element = result.getElement(); if (element instanceof PsiTypeParameterListOwner) { final PsiMethodReferenceExpression copy = createMethodReference(expression, qualifierTypeElement); final JavaResolveResult simplifiedResolve = copy.advancedResolve(false); final PsiElement candidate = simplifiedResolve.getElement(); if (candidate == element) { final PsiJavaCodeReferenceElement referenceElement = qualifierTypeElement.getInnermostComponentReferenceElement(); LOG.assertTrue(referenceElement != null, qualifierTypeElement); final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); LOG.assertTrue(parameterList != null); final ProblemDescriptor descriptor = inspectionManager.createProblemDescriptor( parameterList, InspectionsBundle.message("inspection.redundant.type.problem.descriptor"), new MyMethodReferenceFixAction(), ProblemHighlightType.LIKE_UNUSED_SYMBOL, false); problems.add(descriptor); } } } } }
@Nullable private static PsiClass findClass(PsiNewExpression newExpression) { final PsiJavaCodeReferenceElement classReference = newExpression.getClassOrAnonymousClassReference(); if (classReference != null) { final String text = classReference.getReferenceName(); if (text != null) { final Project project = newExpression.getProject(); final JavaPsiFacade facade = JavaPsiFacade.getInstance(project); final PsiResolveHelper resolveHelper = facade.getResolveHelper(); final PsiExpression newExpressionQualifier = newExpression.getQualifier(); final PsiElement qualifierElement = classReference.getQualifier(); final String qualifier = qualifierElement != null ? qualifierElement.getText() : ""; final String qualifiedName = StringUtil.getQualifiedName(qualifier, text); if (newExpressionQualifier != null) { final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(newExpressionQualifier.getType()); if (aClass != null) { return aClass.findInnerClassByName(qualifiedName, false); } } return resolveHelper.resolveReferencedClass(qualifiedName, newExpression); } else { return null; } } return null; }
private static void autoImport(final PsiFile file, int offset, final Editor editor) { final CharSequence text = editor.getDocument().getCharsSequence(); while (offset > 0 && Character.isJavaIdentifierPart(text.charAt(offset))) offset--; if (offset <= 0) return; while (offset > 0 && Character.isWhitespace(text.charAt(offset))) offset--; if (offset <= 0 || text.charAt(offset) != '.') return; offset--; while (offset > 0 && Character.isWhitespace(text.charAt(offset))) offset--; if (offset <= 0) return; PsiJavaCodeReferenceElement element = extractReference( PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiExpression.class, false)); if (element == null) return; while (true) { final PsiJavaCodeReferenceElement qualifier = extractReference(element.getQualifier()); if (qualifier == null) break; element = qualifier; } if (!(element.getParent() instanceof PsiMethodCallExpression) && element.multiResolve(true).length == 0) { new ImportClassFix(element).doFix(editor, false, false); } }
@NotNull public static String getPresentableText(@NotNull PsiJavaCodeReferenceElement ref) { String name = ref.getReferenceName(); PsiAnnotation[] annotations = PsiTreeUtil.getChildrenOfType(ref, PsiAnnotation.class); return getPresentableText( name, notNull(annotations, PsiAnnotation.EMPTY_ARRAY), ref.getTypeParameters()); }
public ASTNode getDefaultAnchor( @NotNull PsiImportList list, @NotNull PsiImportStatementBase statement) { PsiJavaCodeReferenceElement ref = statement.getImportReference(); if (ref == null) return null; int entryIndex = findEntryIndex(statement); PsiImportStatementBase[] allStatements = list.getAllImportStatements(); int[] entries = ArrayUtil.newIntArray(allStatements.length); List<PsiImportStatementBase> statements = new ArrayList<PsiImportStatementBase>(); for (int i = 0; i < allStatements.length; i++) { PsiImportStatementBase statement1 = allStatements[i]; int entryIndex1 = findEntryIndex(statement1); entries[i] = entryIndex1; if (entryIndex1 == entryIndex) { statements.add(statement1); } } if (statements.isEmpty()) { int index; for (index = entries.length - 1; index >= 0; index--) { if (entries[index] < entryIndex) break; } index++; return index < entries.length ? SourceTreeToPsiMap.psiElementToTree(allStatements[index]) : null; } else { String refText = ref.getCanonicalText(); if (statement.isOnDemand()) { refText += "."; } PsiImportStatementBase insertBefore = null; PsiImportStatementBase insertAfter = null; for (PsiImportStatementBase statement1 : statements) { PsiJavaCodeReferenceElement ref1 = statement1.getImportReference(); if (ref1 == null) { continue; } String refTextThis = ref1.getCanonicalText(); if (statement1.isOnDemand()) { refTextThis += "."; } int comp = Comparing.compare(refText, refTextThis); if (comp < 0 && insertBefore == null) { insertBefore = statement1; } if (comp > 0) { insertAfter = statement1; } } if (insertBefore != null) return insertBefore.getNode(); if (insertAfter != null) return insertAfter.getNode().getTreeNext(); return null; } }
@NotNull private static Import importToImport(@NotNull PsiImportStatementBase i) { PsiJavaCodeReferenceElement reference = i.getImportReference(); if (reference != null) { return new Import(quoteKeywords(reference.getQualifiedName()) + (i.isOnDemand() ? ".*" : "")); } return new Import(""); }
private int substituteToTypeParameters( PsiTypeElement typeElement, PsiTypeElement inplaceTypeElement, PsiType[] paramVals, PsiTypeParameter[] params, TemplateBuilder builder, PsiSubstitutor rawingSubstitutor, boolean toplevel) { PsiType type = inplaceTypeElement.getType(); List<PsiType> types = new ArrayList<>(); for (int i = 0; i < paramVals.length; i++) { PsiType val = paramVals[i]; if (val == null) return SUBSTITUTED_NONE; if (type.equals(val)) { types.add(myFactory.createType(params[i])); } } if (!types.isEmpty()) { Project project = typeElement.getProject(); PsiType substituted = rawingSubstitutor.substitute(type); if (!CommonClassNames.JAVA_LANG_OBJECT.equals(substituted.getCanonicalText()) && (toplevel || substituted.equals(type))) { types.add(substituted); } builder.replaceElement( typeElement, new TypeExpression(project, types.toArray(PsiType.createArray(types.size())))); return toplevel ? SUBSTITUTED_IN_REF : SUBSTITUTED_IN_PARAMETERS; } boolean substituted = false; PsiJavaCodeReferenceElement ref = typeElement.getInnermostComponentReferenceElement(); PsiJavaCodeReferenceElement inplaceRef = inplaceTypeElement.getInnermostComponentReferenceElement(); if (ref != null) { LOG.assertTrue(inplaceRef != null); PsiTypeElement[] innerTypeElements = ref.getParameterList().getTypeParameterElements(); PsiTypeElement[] inplaceInnerTypeElements = inplaceRef.getParameterList().getTypeParameterElements(); for (int i = 0; i < innerTypeElements.length; i++) { substituted |= substituteToTypeParameters( innerTypeElements[i], inplaceInnerTypeElements[i], paramVals, params, builder, rawingSubstitutor, false) != SUBSTITUTED_NONE; } } return substituted ? SUBSTITUTED_IN_PARAMETERS : SUBSTITUTED_NONE; }
public JavaCompletionProcessor( PsiElement element, ElementFilter filter, final boolean checkAccess, boolean checkInitialized, @Nullable Condition<String> nameCondition) { myCheckAccess = checkAccess; mySettings = CodeInsightSettings.getInstance(); myResults = new ArrayList<CompletionElement>(); myElement = element; myMatcher = nameCondition; myFilter = filter; PsiElement scope = element; if (JavaResolveUtil.isInJavaDoc(myElement)) myMembersFlag = true; while (scope != null && !(scope instanceof PsiFile) && !(scope instanceof PsiClass)) { scope = scope.getContext(); } myScope = scope; if (!(element.getContainingFile() instanceof PsiJavaFile)) { myMembersFlag = true; } PsiElement elementParent = element.getContext(); if (elementParent instanceof PsiReferenceExpression) { PsiExpression qualifier = ((PsiReferenceExpression) elementParent).getQualifierExpression(); if (qualifier instanceof PsiSuperExpression) { final PsiJavaCodeReferenceElement qSuper = ((PsiSuperExpression) qualifier).getQualifier(); if (qSuper == null) { myQualifierClass = JavaResolveUtil.getContextClass(myElement); } else { final PsiElement target = qSuper.resolve(); myQualifierClass = target instanceof PsiClass ? (PsiClass) target : null; } if (myQualifierClass != null) { myQualifierType = JavaPsiFacade.getInstance(element.getProject()) .getElementFactory() .createType(myQualifierClass); } } else if (qualifier != null) { myQualifierType = qualifier.getType(); myQualifierClass = PsiUtil.resolveClassInType(myQualifierType); if (myQualifierType == null && qualifier instanceof PsiJavaCodeReferenceElement) { final PsiElement target = ((PsiJavaCodeReferenceElement) qualifier).resolve(); if (target instanceof PsiClass) { myQualifierClass = (PsiClass) target; } } } } if (checkInitialized) { myNonInitializedFields.addAll(getNonInitializedFields(element)); } }
public static DiamondInferenceResult resolveInferredTypesNoCheck( final PsiNewExpression newExpression, final PsiElement context) { final PsiClass psiClass = findClass(newExpression); if (psiClass == null) return DiamondInferenceResult.NULL_RESULT; final PsiExpressionList argumentList = newExpression.getArgumentList(); if (argumentList == null) return DiamondInferenceResult.NULL_RESULT; final Ref<PsiMethod> staticFactoryRef = new Ref<PsiMethod>(); final PsiSubstitutor inferredSubstitutor = ourDiamondGuard.doPreventingRecursion( context, false, new Computable<PsiSubstitutor>() { @Override public PsiSubstitutor compute() { final PsiMethod constructor = findConstructor(psiClass, newExpression); PsiTypeParameter[] params = getAllTypeParams(constructor, psiClass); final PsiMethod staticFactory = generateStaticFactory( constructor, psiClass, params, newExpression.getClassReference()); if (staticFactory == null) { return null; } staticFactoryRef.set(staticFactory); return inferTypeParametersForStaticFactory( staticFactory, newExpression, context, false); } }); if (inferredSubstitutor == null) { return DiamondInferenceResult.NULL_RESULT; } final PsiMethod staticFactory = staticFactoryRef.get(); if (staticFactory == null) { LOG.error(inferredSubstitutor); return DiamondInferenceResult.NULL_RESULT; } final PsiTypeParameter[] parameters = staticFactory.getTypeParameters(); final PsiTypeParameter[] classParameters = psiClass.getTypeParameters(); final PsiJavaCodeReferenceElement classOrAnonymousClassReference = newExpression.getClassOrAnonymousClassReference(); LOG.assertTrue(classOrAnonymousClassReference != null); final DiamondInferenceResult result = new DiamondInferenceResult(classOrAnonymousClassReference.getReferenceName() + "<>"); for (PsiTypeParameter parameter : parameters) { for (PsiTypeParameter classParameter : classParameters) { if (Comparing.strEqual(classParameter.getName(), parameter.getName())) { result.addInferredType(inferredSubstitutor.substitute(parameter)); break; } } } return result; }
public int findEntryIndex(@NotNull PsiImportStatementBase statement) { PsiJavaCodeReferenceElement ref = statement.getImportReference(); if (ref == null) return -1; String packageName; if (statement.isOnDemand()) { packageName = ref.getCanonicalText(); } else { String className = ref.getCanonicalText(); packageName = getPackageOrClassName(className); } return findEntryIndex(packageName); }
@Override public void visitThisExpression(PsiThisExpression expression) { super.visitThisExpression(expression); final PsiJavaCodeReferenceElement qualifier = expression.getQualifier(); if (qualifier != null && qualifier.isReferenceTo(mySourceClass)) { try { qualifier.bindToElement(myTargetSuperClass); } catch (IncorrectOperationException e) { LOG.error(e); } } }
@Override public void beforeCompletion(@NotNull final CompletionInitializationContext context) { final PsiFile file = context.getFile(); if (file instanceof PsiJavaFile) { JavaCompletionUtil.initOffsets(file, context.getOffsetMap()); autoImport(file, context.getStartOffset() - 1, context.getEditor()); if (context.getCompletionType() == CompletionType.BASIC) { if (semicolonNeeded(context.getEditor(), file, context.getStartOffset())) { context.setDummyIdentifier(CompletionInitializationContext.DUMMY_IDENTIFIER.trim() + ";"); return; } final PsiJavaCodeReferenceElement ref = PsiTreeUtil.findElementOfClassAtOffset( file, context.getStartOffset(), PsiJavaCodeReferenceElement.class, false); if (ref != null && !(ref instanceof PsiReferenceExpression)) { if (ref.getParent() instanceof PsiTypeElement) { context.setDummyIdentifier( CompletionInitializationContext.DUMMY_IDENTIFIER.trim() + ";"); } if (JavaSmartCompletionContributor.AFTER_NEW.accepts(ref)) { final PsiReferenceParameterList paramList = ref.getParameterList(); if (paramList != null && paramList.getTextLength() > 0) { context .getOffsetMap() .addOffset( ConstructorInsertHandler.PARAM_LIST_START, paramList.getTextRange().getStartOffset()); context .getOffsetMap() .addOffset( ConstructorInsertHandler.PARAM_LIST_END, paramList.getTextRange().getEndOffset()); } } return; } final PsiElement element = file.findElementAt(context.getStartOffset()); if (psiElement().inside(PsiAnnotation.class).accepts(element)) { return; } context.setDummyIdentifier(CompletionInitializationContext.DUMMY_IDENTIFIER_TRIMMED); } } }
@Nullable private static PsiReferenceParameterList extractReferenceParameterList( final PsiClass superClass, final PsiReferenceList extendsList) { for (PsiJavaCodeReferenceElement referenceElement : extendsList.getReferenceElements()) { final PsiElement element = referenceElement.resolve(); if (element instanceof PsiClass && InheritanceUtil.isInheritorOrSelf((PsiClass) element, superClass, true)) { return referenceElement.getParameterList(); } } return null; }
@Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); if (reference.getQualifier() != null) { return; } final PsiElement target = reference.resolve(); if (!(target instanceof PsiClass) || !PsiUtil.isLocalClass((PsiClass) target)) { return; } referenceToLocalClass = true; }
private static PsiElement getElement(PsiElement targetElement) { if (targetElement instanceof PsiNewExpression) { PsiJavaCodeReferenceElement referenceElement = getReferenceElement((PsiNewExpression) targetElement); if (referenceElement == null) return null; return referenceElement.getReferenceNameElement(); } else if (targetElement instanceof PsiEnumConstant) { return targetElement; } return null; }
private static void decodeRef( final PsiJavaCodeReferenceElement expression, final Map<PsiClass, PsiElement> oldToNewMap, Set<PsiElement> rebindExpressions) { final PsiElement resolved = expression.resolve(); if (resolved instanceof PsiClass) { final PsiClass psiClass = (PsiClass) resolved; if (oldToNewMap.containsKey(psiClass)) { rebindExpressions.add(expression.bindToElement(oldToNewMap.get(psiClass))); } } }