Java PsiEquivalenceUtil类代码示例

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
@Override
public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) throws IncorrectOperationException {
  if (!FileModificationService.getInstance().preparePsiElementForWrite(element)) return;

  final PsiConditionalExpression conditionalExpression = PsiTreeUtil.getParentOfType(element, PsiConditionalExpression.class);
  final PsiExpression thenExpression = (PsiExpression)conditionalExpression.getThenExpression().copy();
  final PsiExpressionList thenArgsList = ((PsiCallExpression)thenExpression).getArgumentList();
  final PsiExpression[] thenExpressions = thenArgsList.getExpressions();

  final PsiExpression elseExpression = conditionalExpression.getElseExpression();
  final PsiExpressionList elseArgsList = ((PsiCallExpression)elseExpression).getArgumentList();
  final PsiExpression[] elseExpressions = elseArgsList.getExpressions();


  for (int i = 0; i < thenExpressions.length; i++) {
    PsiExpression lExpr = thenExpressions[i];
    PsiExpression rExpr = elseExpressions[i];
    if (!PsiEquivalenceUtil.areElementsEquivalent(lExpr, rExpr)) {
      lExpr.replace(JavaPsiFacade.getElementFactory(project).createExpressionFromText(
        conditionalExpression.getCondition().getText() + "?" + lExpr.getText() + ":" + rExpr.getText(), lExpr));
      break;
    }
  }

  CodeStyleManager.getInstance(project).reformat(conditionalExpression.replace(thenExpression));
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private void areExitStatementsTheSame() throws ExitStatementsNotSameException {
  if (myExitStatements.isEmpty()) {
    throw new ExitStatementsNotSameException();
  }
  PsiStatement first = null;
  for (PsiStatement statement : myExitStatements) {
    if (first == null) {
      first = statement;
      continue;
    }
    if (!PsiEquivalenceUtil.areElementsEquivalent(first, statement)) {
      throw new ExitStatementsNotSameException();
    }
  }

  myFirstExitStatementCopy = (PsiStatement)first.copy();
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
public static List<ParameterInfoImpl> patchParams(Map<PsiVariable, PsiType> changedParams, final PsiMethod psiMethod) {
  final ArrayList<ParameterInfoImpl> newParameters = new ArrayList<ParameterInfoImpl>();
  final PsiParameter[] oldParameters = psiMethod.getParameterList().getParameters();
  for (int i = 0; i < oldParameters.length; i++) {
    final PsiParameter oldParameter = oldParameters[i];
    PsiType type = oldParameter.getType();
    for (PsiVariable variable : changedParams.keySet()) {
      if (PsiEquivalenceUtil.areElementsEquivalent(variable, oldParameter)) {
        type = changedParams.get(variable);
        break;
      }
    }
    newParameters.add(new ParameterInfoImpl(i, oldParameter.getName(), type));
  }
  return newParameters;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
@Nullable
static MyStyleData getInlinableStyleDataFromContext(@Nullable PsiElement context) {
  if (context instanceof LazyValueResourceElementWrapper) {
    context = ((LazyValueResourceElementWrapper)context).computeElement();
  }
  if (context == null || !context.getManager().isInProject(context)) {
    return null;
  }
  final XmlAttributeValue attrValue = PsiTreeUtil.getParentOfType(context, XmlAttributeValue.class, false);
  final XmlTag tag = attrValue != null ? PsiTreeUtil.getParentOfType(attrValue, XmlTag.class) : null;

  if (tag == null) {
    return null;
  }
  final MyStyleData data = getInlinableStyleData(tag);
  return data != null && PsiEquivalenceUtil.areElementsEquivalent(data.myReferredElement, attrValue)
         ? data : null;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private static boolean checkForListIsEmpty(GrExpression condition, GrExpression elseBranch) {
  if (condition instanceof GrMethodCall) condition = ((GrMethodCall)condition).getInvokedExpression();
  if (!(condition instanceof GrReferenceExpression)) return false;

  final GrExpression qualifier = ((GrReferenceExpression)condition).getQualifier();
  if (qualifier == null) return false;

  if (!PsiEquivalenceUtil.areElementsEquivalent(qualifier, elseBranch)) return false;

  final PsiType type = qualifier.getType();
  if (type == null) return false;
  if (!InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_LIST)) return false;

  final PsiElement resolved = ((GrReferenceExpression)condition).resolve();

  return resolved instanceof PsiMethod &&
         "isEmpty".equals(((PsiMethod)resolved).getName()) &&
         ((PsiMethod)resolved).getParameterList().getParametersCount() == 0;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
/**
 * checks for the case string.isEmpty() ? something_else : string
 */
private static boolean checkForStringIsEmpty(GrExpression condition, GrExpression elseBranch) {
  if (condition instanceof GrMethodCall) condition = ((GrMethodCall)condition).getInvokedExpression();
  if (!(condition instanceof GrReferenceExpression)) return false;

  final GrExpression qualifier = ((GrReferenceExpression)condition).getQualifier();
  if (qualifier == null) return false;

  if (!PsiEquivalenceUtil.areElementsEquivalent(qualifier, elseBranch)) return false;

  final PsiType type = qualifier.getType();
  if (type == null) return false;
  if (!type.equalsToText(CommonClassNames.JAVA_LANG_STRING)) return false;

  final PsiElement resolved = ((GrReferenceExpression)condition).resolve();

  return resolved instanceof PsiMethod &&
         "isEmpty".equals(((PsiMethod)resolved).getName()) &&
         ((PsiMethod)resolved).getParameterList().getParametersCount() == 0;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private static boolean checkForNull(GrExpression condition, GrExpression then) {
  if (!(condition instanceof GrBinaryExpression)) return false;

  GrBinaryExpression binaryExpression = (GrBinaryExpression)condition;
  if (GroovyTokenTypes.mNOT_EQUAL != binaryExpression.getOperationTokenType()) return false;

  GrExpression left = binaryExpression.getLeftOperand();
  GrExpression right = binaryExpression.getRightOperand();
  if (left instanceof GrLiteral && "null".equals(left.getText()) && right != null) {
    return PsiEquivalenceUtil.areElementsEquivalent(right, then);
  }
  if (right instanceof GrLiteral && "null".equals(right.getText())) {
    return PsiEquivalenceUtil.areElementsEquivalent(left, then);
  }

  return false;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private void addVariantsWithSameQualifier(@NotNull PsiElement element, @NotNull Set<String> result) {
  if (element instanceof GrReferenceExpression && element != myRefExpr && !PsiUtil.isLValue((GroovyPsiElement)element)) {
    final GrReferenceExpression refExpr = (GrReferenceExpression)element;
    final String refName = refExpr.getReferenceName();
    if (refName != null && !result.contains(refName) && myMatcher.prefixMatches(refName)) {
      final GrExpression hisQualifier = refExpr.getQualifierExpression();
      if (hisQualifier != null && myQualifier != null) {
        if (PsiEquivalenceUtil.areElementsEquivalent(hisQualifier, myQualifier)) {
          if (refExpr.resolve() == null) {
            result.add(refName);
          }
        }
      }
      else if (hisQualifier == null && myQualifier == null) {
        if (refExpr.resolve() == null) {
          result.add(refName);
        }
      }
    }
  }

  for (PsiElement child = element.getFirstChild(); child != null; child = child.getNextSibling()) {
    addVariantsWithSameQualifier(child, result);
  }
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private static boolean matchPattern(@Nullable final PsiElement pattern,
                                    @Nullable final PsiElement candidate,
                                    @NotNull final SimpleMatch match) {
  ProgressManager.checkCanceled();
  if (pattern == null || candidate == null) return pattern == candidate;
  final PsiElement[] children1 = PsiEquivalenceUtil.getFilteredChildren(pattern, null, true);
  final PsiElement[] children2 = PsiEquivalenceUtil.getFilteredChildren(candidate, null, true);
  if (children1.length != children2.length) return false;

  for (int i = 0; i < children1.length; i++) {
    final PsiElement child1 = children1[i];
    final PsiElement child2 = children2[i];
    if (!matchPattern(child1, child2, match)) return false;
  }

  if (children1.length == 0) {
    if (pattern.getUserData(PARAMETER) != null && pattern.getParent().getClass() == candidate.getParent().getClass()) {
      match.changeParameter(pattern.getText(), candidate.getText());
      return true;
    }
    if (!pattern.textMatches(candidate)) return false;
  }

  return true;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
@NotNull
public static List<PsiElement> getOccurrences(@NotNull final PsiElement pattern, @Nullable final PsiElement context) {
  if (context == null) {
    return Collections.emptyList();
  }
  final List<PsiElement> occurrences = new ArrayList<PsiElement>();
  final HaxeVisitor visitor = new HaxeVisitor() {
    public void visitElement(@NotNull final PsiElement element) {
      if (element instanceof HaxeParameter) {
        return;
      }
      if (PsiEquivalenceUtil.areElementsEquivalent(element, pattern)) {
        occurrences.add(element);
        return;
      }
      element.acceptChildren(this);
    }
  };
  context.acceptChildren(visitor);
  return occurrences;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
protected static void addExpressionOccurrences(JSExpression expr, List<JSExpression> array, PsiElement scope)
{
	PsiElement[] children = scope.getChildren();

	for(PsiElement child : children)
	{
		if(child instanceof JSExpression)
		{
			final JSExpression childExpression = unparenthesize((JSExpression) child);

			if(childExpression != null &&
					PsiEquivalenceUtil.areElementsEquivalent(childExpression, expr) &&
					!JSResolveUtil.isSelfReference(scope, child))
			{
				array.add((JSExpression) child);
				continue;
			}
		}
		if(!(child instanceof JSFunction))
		{
			addExpressionOccurrences(expr, array, child);
		}
	}
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private void areExitStatementsTheSame() throws ExitStatementsNotSameException
{
	if(myExitStatements.isEmpty())
	{
		throw new ExitStatementsNotSameException();
	}
	PsiStatement first = null;
	for(PsiStatement statement : myExitStatements)
	{
		if(first == null)
		{
			first = statement;
			continue;
		}
		if(!PsiEquivalenceUtil.areElementsEquivalent(first, statement))
		{
			throw new ExitStatementsNotSameException();
		}
	}

	myFirstExitStatementCopy = (PsiStatement) first.copy();
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
private static void collectOccurrences(@NotNull PsiElement expr, @NotNull PsiElement scope, @NotNull ArrayList<PsiElement> acc, Comparator<PsiElement> comparator, boolean goIntoInner) {
    if (scope.equals(expr)) {
      acc.add(expr);
      return;
    }
    for (PsiElement child : scope.getChildren()) {
//      if (goIntoInner || !(scope instanceof LuaPsiFileBase)) {
        if (PsiEquivalenceUtil.areElementsEquivalent(child, expr, comparator, false)) {
          acc.add(child);
        } else {
          collectOccurrences(expr, child, acc, comparator, goIntoInner);
        }
      }
//    }
  }
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
@Nullable
private static PsiExpression findEquivalent(PsiExpression expr, PsiElement element) {
  PsiElement expression = element;
  while (expression  != null) {
    if (PsiEquivalenceUtil.areElementsEquivalent(expression, expr)) {
      return (PsiExpression)expression;
    }
    expression = PsiTreeUtil.getParentOfType(expression, PsiExpression.class);
  }
  return null;
}
 

import com.intellij.codeInsight.PsiEquivalenceUtil; //导入依赖的package包/类
boolean registerInstanceExpression(PsiExpression instanceExpression, final PsiClass contextClass) {
  if (myInstanceExpression == null) {
    if (instanceExpression != null) {
      final PsiType type = instanceExpression.getType();
      if (!(type instanceof PsiClassType)) return false;
      final PsiClass hisClass = ((PsiClassType) type).resolve();
      if (hisClass == null || !InheritanceUtil.isInheritorOrSelf(hisClass, contextClass, true)) return false;
    }
    myInstanceExpression = Ref.create(instanceExpression);
    return true;
  }
  else {
    if (myInstanceExpression.get() == null) {
      myInstanceExpression.set(instanceExpression);

      return instanceExpression == null;
    }
    else {
      if (instanceExpression != null) {
        return PsiEquivalenceUtil.areElementsEquivalent(instanceExpression, myInstanceExpression.get());
      }
      else {
        return myInstanceExpression.get() == null || myInstanceExpression.get() instanceof PsiThisExpression;
      }
    }
  }
}