public boolean commitTransaction(final Document document) {
ApplicationManager.getApplication().assertIsDispatchThread();
final DocumentChangeTransaction documentChangeTransaction = removeTransaction(document);
if (documentChangeTransaction == null) return false;
final PsiElement changeScope = documentChangeTransaction.getChangeScope();
try {
mySyncDocument = document;
final PsiTreeChangeEventImpl fakeEvent = new PsiTreeChangeEventImpl(changeScope.getManager());
fakeEvent.setParent(changeScope);
fakeEvent.setFile(changeScope.getContainingFile());
doSync(
fakeEvent,
true,
new DocSyncAction() {
@Override
public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
doCommitTransaction(document, documentChangeTransaction);
}
});
myBus
.syncPublisher(PsiDocumentTransactionListener.TOPIC)
.transactionCompleted(document, (PsiFile) changeScope);
} finally {
mySyncDocument = null;
}
return true;
}
@Nullable
public static CreateClassOrPackageFix createFix(
@NotNull final String qualifiedName,
@NotNull final GlobalSearchScope scope,
@NotNull final PsiElement context,
@Nullable final PsiPackage basePackage,
@Nullable ClassKind kind,
@Nullable String superClass,
@Nullable String templateName) {
final List<PsiDirectory> directories =
getWritableDirectoryListDefault(basePackage, scope, context.getManager());
if (directories.isEmpty()) {
return null;
}
final String redPart =
basePackage == null
? qualifiedName
: qualifiedName.substring(basePackage.getQualifiedName().length() + 1);
final int dot = redPart.indexOf('.');
final boolean fixPath = dot >= 0;
final String firstRedName = fixPath ? redPart.substring(0, dot) : redPart;
for (Iterator<PsiDirectory> i = directories.iterator(); i.hasNext(); ) {
if (!checkCreateClassOrPackage(kind != null && !fixPath, i.next(), firstRedName)) {
i.remove();
}
}
return new CreateClassOrPackageFix(
directories,
context,
fixPath ? qualifiedName : redPart,
redPart,
kind,
superClass,
templateName);
}
private JavaResolveResult advancedResolveInner(final PsiElement psiElement, final String qName) {
final PsiManager manager = psiElement.getManager();
final GlobalSearchScope scope = getScope();
if (myIndex == myJavaClassReferenceSet.getReferences().length - 1) {
final PsiClass aClass =
JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
if (aClass != null) {
return new ClassCandidateInfo(aClass, PsiSubstitutor.EMPTY, false, psiElement);
} else {
if (!JavaClassReferenceProvider.ADVANCED_RESOLVE.getBooleanValue(getOptions())) {
return JavaResolveResult.EMPTY;
}
}
}
PsiElement resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findPackage(qName);
if (resolveResult == null) {
resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
}
if (myInStaticImport && resolveResult == null) {
resolveResult = resolveMember(qName, manager, getElement().getResolveScope());
}
if (resolveResult == null) {
PsiFile containingFile = psiElement.getContainingFile();
if (containingFile instanceof PsiJavaFile) {
if (containingFile instanceof JspFile) {
containingFile = containingFile.getViewProvider().getPsi(StdLanguages.JAVA);
if (containingFile == null) return JavaResolveResult.EMPTY;
}
final ClassResolverProcessor processor =
new ClassResolverProcessor(getCanonicalText(), psiElement);
containingFile.processDeclarations(processor, ResolveState.initial(), null, psiElement);
if (processor.getResult().length == 1) {
final JavaResolveResult javaResolveResult = processor.getResult()[0];
if (javaResolveResult != JavaResolveResult.EMPTY && getOptions() != null) {
final Boolean value =
JavaClassReferenceProvider.RESOLVE_QUALIFIED_CLASS_NAME.getValue(getOptions());
final PsiClass psiClass = (PsiClass) javaResolveResult.getElement();
if (value != null && value.booleanValue() && psiClass != null) {
final String qualifiedName = psiClass.getQualifiedName();
if (!qName.equals(qualifiedName)) {
return JavaResolveResult.EMPTY;
}
}
}
return javaResolveResult;
}
}
}
return resolveResult != null
? new CandidateInfo(resolveResult, PsiSubstitutor.EMPTY, false, false, psiElement)
: JavaResolveResult.EMPTY;
}
@Override
public boolean setupDefaultValues(
ChangeInfo changeInfo, Ref<UsageInfo[]> refUsages, Project project) {
if (!(changeInfo instanceof JavaChangeInfo)) return true;
for (UsageInfo usageInfo : refUsages.get()) {
if (usageInfo instanceof MethodCallUsageInfo) {
MethodCallUsageInfo methodCallUsageInfo = (MethodCallUsageInfo) usageInfo;
if (methodCallUsageInfo.isToChangeArguments()) {
final PsiElement element = methodCallUsageInfo.getElement();
if (element == null) continue;
final PsiMethod caller = RefactoringUtil.getEnclosingMethod(element);
final boolean needDefaultValue = needDefaultValue(changeInfo, caller);
if (needDefaultValue
&& (caller == null
|| !MethodSignatureUtil.isSuperMethod(
methodCallUsageInfo.getReferencedMethod(), caller))) {
final ParameterInfo[] parameters = changeInfo.getNewParameters();
for (ParameterInfo parameter : parameters) {
final String defaultValue = parameter.getDefaultValue();
if (defaultValue == null && parameter.getOldIndex() == -1) {
((ParameterInfoImpl) parameter).setDefaultValue("");
if (!ApplicationManager.getApplication().isUnitTestMode()) {
final PsiType type =
((ParameterInfoImpl) parameter)
.getTypeWrapper()
.getType(element, element.getManager());
final DefaultValueChooser chooser =
new DefaultValueChooser(
project, parameter.getName(), PsiTypesUtil.getDefaultValueOfType(type));
chooser.show();
if (chooser.isOK()) {
if (chooser.feelLucky()) {
parameter.setUseAnySingleVariable(true);
} else {
((ParameterInfoImpl) parameter).setDefaultValue(chooser.getDefaultValue());
}
} else {
return false;
}
}
}
}
}
}
}
}
return true;
}
@NotNull
public static UsageInfo[] findUsages(
final PsiElement element,
final String newName,
boolean searchInStringsAndComments,
boolean searchForTextOccurrences,
Map<? extends PsiElement, String> allRenames) {
final List<UsageInfo> result = Collections.synchronizedList(new ArrayList<UsageInfo>());
PsiManager manager = element.getManager();
GlobalSearchScope projectScope = GlobalSearchScope.projectScope(manager.getProject());
RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(element);
Collection<PsiReference> refs = processor.findReferences(element, searchInStringsAndComments);
for (final PsiReference ref : refs) {
if (ref == null) {
LOG.error("null reference from processor " + processor);
continue;
}
PsiElement referenceElement = ref.getElement();
result.add(
new MoveRenameUsageInfo(
referenceElement,
ref,
ref.getRangeInElement().getStartOffset(),
ref.getRangeInElement().getEndOffset(),
element,
ref.resolve() == null));
}
processor.findCollisions(element, newName, allRenames, result);
final PsiElement searchForInComments =
processor.getElementToSearchInStringsAndComments(element);
if (searchInStringsAndComments && searchForInComments != null) {
String stringToSearch =
ElementDescriptionUtil.getElementDescription(
searchForInComments, NonCodeSearchDescriptionLocation.STRINGS_AND_COMMENTS);
if (stringToSearch.length() > 0) {
final String stringToReplace = getStringToReplace(element, newName, false, processor);
TextOccurrencesUtil.UsageInfoFactory factory =
new NonCodeUsageInfoFactory(searchForInComments, stringToReplace);
TextOccurrencesUtil.addUsagesInStringsAndComments(
searchForInComments, stringToSearch, result, factory);
}
}
if (searchForTextOccurrences && searchForInComments != null) {
String stringToSearch =
ElementDescriptionUtil.getElementDescription(
searchForInComments, NonCodeSearchDescriptionLocation.NON_JAVA);
if (stringToSearch.length() > 0) {
final String stringToReplace = getStringToReplace(element, newName, true, processor);
addTextOccurrence(
searchForInComments, result, projectScope, stringToSearch, stringToReplace);
}
final Pair<String, String> additionalStringToSearch =
processor.getTextOccurrenceSearchStrings(searchForInComments, newName);
if (additionalStringToSearch != null && additionalStringToSearch.first.length() > 0) {
addTextOccurrence(
searchForInComments,
result,
projectScope,
additionalStringToSearch.first,
additionalStringToSearch.second);
}
}
return result.toArray(new UsageInfo[result.size()]);
}
static PsiSubstitutor infer(
@NotNull PsiTypeParameter[] typeParameters,
@NotNull PsiParameter[] parameters,
@NotNull PsiExpression[] arguments,
@NotNull PsiSubstitutor partialSubstitutor,
@NotNull final PsiElement parent,
@NotNull final ParameterTypeInferencePolicy policy) {
if (parent instanceof PsiCall) {
final PsiExpressionList argumentList = ((PsiCall) parent).getArgumentList();
final MethodCandidateInfo.CurrentCandidateProperties properties =
MethodCandidateInfo.getCurrentMethod(argumentList);
// overload resolution can't depend on outer call => should not traverse to top
if (properties != null
&& !properties.isApplicabilityCheck()
&&
// in order to to avoid caching of candidates's errors on parent (!) , so check for
// overload resolution is left here
// But overload resolution can depend on type of lambda parameter. As it can't depend on
// lambda body,
// traversing down would stop at lambda level and won't take into account overloaded
// method
!MethodCandidateInfo.ourOverloadGuard.currentStack().contains(argumentList)) {
final PsiCall topLevelCall =
PsiResolveHelper.ourGraphGuard.doPreventingRecursion(
parent,
false,
new Computable<PsiCall>() {
@Override
public PsiCall compute() {
if (parent instanceof PsiExpression
&& !PsiPolyExpressionUtil.isPolyExpression((PsiExpression) parent)) {
return null;
}
return LambdaUtil.treeWalkUp(parent);
}
});
if (topLevelCall != null) {
InferenceSession session;
if (MethodCandidateInfo.isOverloadCheck()
|| !PsiDiamondType.ourDiamondGuard.currentStack().isEmpty()
|| LambdaUtil.isLambdaParameterCheck()) {
session = startTopLevelInference(topLevelCall, policy);
} else {
session =
CachedValuesManager.getCachedValue(
topLevelCall,
new CachedValueProvider<InferenceSession>() {
@Nullable
@Override
public Result<InferenceSession> compute() {
return new Result<InferenceSession>(
startTopLevelInference(topLevelCall, policy),
PsiModificationTracker.MODIFICATION_COUNT);
}
});
if (session != null) {
// reject cached top level session if it was based on wrong candidate: check nested
// session if candidate (it's type parameters) are the same
// such situations are avoided when overload resolution is performed
// (MethodCandidateInfo.isOverloadCheck above)
// but situations when client code iterates through
// PsiResolveHelper.getReferencedMethodCandidates or similar are impossible to guess
final Map<PsiElement, InferenceSession> sessions =
session.getInferenceSessionContainer().myNestedSessions;
final InferenceSession childSession = sessions.get(parent);
if (childSession != null) {
for (PsiTypeParameter parameter : typeParameters) {
if (!childSession
.getInferenceSubstitution()
.getSubstitutionMap()
.containsKey(parameter)) {
session = startTopLevelInference(topLevelCall, policy);
break;
}
}
}
}
}
if (session != null) {
final PsiSubstitutor childSubstitutor =
inferNested(
typeParameters,
parameters,
arguments,
partialSubstitutor,
(PsiCall) parent,
policy,
properties,
session);
if (childSubstitutor != null) return childSubstitutor;
} else if (topLevelCall instanceof PsiMethodCallExpression) {
return new InferenceSession(
typeParameters, partialSubstitutor, parent.getManager(), parent, policy)
.prepareSubstitution();
}
}
}
}
final InferenceSession inferenceSession =
new InferenceSession(
typeParameters, partialSubstitutor, parent.getManager(), parent, policy);
inferenceSession.initExpressionConstraints(parameters, arguments, parent);
return inferenceSession.infer(parameters, arguments, parent);
}
public static Processor<PsiClass> createInheritorsProcessor(
final PsiElement context,
final PsiClassType baseType,
final int arrayDim,
final boolean getRawSubtypes,
final Consumer<PsiType> result,
@NotNull final PsiClass baseClass,
final PsiSubstitutor baseSubstitutor) {
final PsiManager manager = context.getManager();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
return new Processor<PsiClass>() {
@Override
public boolean process(final PsiClass inheritor) {
ProgressManager.checkCanceled();
return ApplicationManager.getApplication()
.runReadAction(
new Computable<Boolean>() {
@Override
public Boolean compute() {
if (!context.isValid()
|| !inheritor.isValid()
|| !facade.getResolveHelper().isAccessible(inheritor, context, null))
return true;
if (inheritor.getQualifiedName() == null
&& !manager.areElementsEquivalent(
inheritor.getContainingFile(),
context.getContainingFile().getOriginalFile())) {
return true;
}
if (JavaCompletionUtil.isInExcludedPackage(inheritor, false)) return true;
PsiSubstitutor superSubstitutor =
TypeConversionUtil.getClassSubstitutor(
baseClass, inheritor, PsiSubstitutor.EMPTY);
if (superSubstitutor == null) return true;
if (getRawSubtypes) {
result.consume(
createType(
inheritor,
facade.getElementFactory().createRawSubstitutor(inheritor),
arrayDim));
return true;
}
PsiSubstitutor inheritorSubstitutor = PsiSubstitutor.EMPTY;
for (PsiTypeParameter inheritorParameter :
PsiUtil.typeParametersIterable(inheritor)) {
for (PsiTypeParameter baseParameter :
PsiUtil.typeParametersIterable(baseClass)) {
final PsiType substituted = superSubstitutor.substitute(baseParameter);
PsiType arg = baseSubstitutor.substitute(baseParameter);
if (arg instanceof PsiWildcardType) {
PsiType bound = ((PsiWildcardType) arg).getBound();
arg = bound != null ? bound : ((PsiWildcardType) arg).getExtendsBound();
}
PsiType substitution =
resolveHelper.getSubstitutionForTypeParameter(
inheritorParameter,
substituted,
arg,
true,
PsiUtil.getLanguageLevel(context));
if (PsiType.NULL.equals(substitution)
|| substitution instanceof PsiWildcardType) continue;
if (substitution == null) {
result.consume(
createType(
inheritor,
facade.getElementFactory().createRawSubstitutor(inheritor),
arrayDim));
return true;
}
inheritorSubstitutor =
inheritorSubstitutor.put(inheritorParameter, substitution);
break;
}
}
PsiType toAdd = createType(inheritor, inheritorSubstitutor, arrayDim);
if (baseType.isAssignableFrom(toAdd)) {
result.consume(toAdd);
}
return true;
}
})
.booleanValue();
}
};
}
