Java Match类代码示例

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
public List<Match> getDuplicates(final PsiMethod method, final PsiMethodCallExpression methodCall, ParametersFolder folder) {
  final List<Match> duplicates = findDuplicatesSignature(method, folder);
  if (duplicates != null && !duplicates.isEmpty()) {
    if (ApplicationManager.getApplication().isUnitTestMode() || 
        new PreviewDialog(method, myExtractedMethod, methodCall, myMethodCall, duplicates.size()).showAndGet()) {
      PsiDocumentManager.getInstance(myProject).commitAllDocuments();
      WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
        @Override
        public void run() {
          myMethodCall = (PsiMethodCallExpression)methodCall.replace(myMethodCall);
          myExtractedMethod = (PsiMethod)method.replace(myExtractedMethod);
        }
      });

      final DuplicatesFinder finder = MethodDuplicatesHandler.createDuplicatesFinder(myExtractedMethod);
      if (finder != null) {
        final List<VariableData> datas = finder.getParameters().getInputVariables();
        myVariableData = datas.toArray(new VariableData[datas.size()]);
        return finder.findDuplicates(myExtractedMethod.getContainingClass());
      }
    }
  }
  return null;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
private static boolean collectParamValues(List<Match> duplicates, VariableData variableData, THashSet<PsiExpression> map) {
  for (Match duplicate : duplicates) {
    final List<PsiElement> values = duplicate.getParameterValues(variableData.variable);
    if (values == null || values.isEmpty()) {
      return false;
    }
    boolean found = false;
    for (PsiElement value : values) {
      if (value instanceof PsiExpression) {
        map.add((PsiExpression)value);
        found = true;
        break;
      }
    }
    if (!found) return false;
  }
  return true;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
private static List<Match> filterChainedConstructorDuplicates(final List<Match> duplicates)
{
	List<Match> result = new ArrayList<Match>();
	for(Match duplicate : duplicates)
	{
		final PsiElement matchStart = duplicate.getMatchStart();
		final PsiMethod method = PsiTreeUtil.getParentOfType(matchStart, PsiMethod.class);
		if(method != null && method.isConstructor())
		{
			final PsiCodeBlock body = method.getBody();
			if(body != null)
			{
				final PsiStatement[] psiStatements = body.getStatements();
				if(psiStatements.length > 0 && matchStart == psiStatements[0])
				{
					result.add(duplicate);
				}
			}
		}
	}
	return result;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Override
public Boolean hasDuplicates()
{
	List<Match> duplicates = getDuplicates();
	if(duplicates != null && !duplicates.isEmpty())
	{
		return true;
	}

	if(myExtractedMethod != null)
	{
		final ExtractMethodSignatureSuggester suggester = new ExtractMethodSignatureSuggester(myProject, myExtractedMethod, myMethodCall, myVariableDatum);
		duplicates = suggester.getDuplicates(myExtractedMethod, myMethodCall, myInputVariables.getFolding());
		if(duplicates != null && !duplicates.isEmpty())
		{
			myDuplicates = duplicates;
			myExtractedMethod = suggester.getExtractedMethod();
			myMethodCall = suggester.getMethodCall();
			myVariableDatum = suggester.getVariableData();
			return null;
		}
	}
	return false;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Override
@Nullable
public String getConfirmDuplicatePrompt(Match match)
{
	final boolean needToBeStatic = RefactoringUtil.isInStaticContext(match.getMatchStart(), myExtractedMethod.getContainingClass());
	final String changedSignature = MatchUtil.getChangedSignature(match, myExtractedMethod, needToBeStatic, VisibilityUtil.getVisibilityStringToDisplay(myExtractedMethod));
	if(changedSignature != null)
	{
		return RefactoringBundle.message("replace.this.code.fragment.and.change.signature", changedSignature);
	}
	if(needToBeStatic && !myExtractedMethod.hasModifierProperty(PsiModifier.STATIC))
	{
		return RefactoringBundle.message("replace.this.code.fragment.and.make.method.static");
	}
	return null;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
private static boolean collectParamValues(List<Match> duplicates, VariableData variableData, THashSet<PsiExpression> map)
{
	for(Match duplicate : duplicates)
	{
		final List<PsiElement> values = duplicate.getParameterValues(variableData.variable);
		if(values == null || values.isEmpty())
		{
			return false;
		}
		boolean found = false;
		for(PsiElement value : values)
		{
			if(value instanceof PsiExpression)
			{
				map.add((PsiExpression) value);
				found = true;
				break;
			}
		}
		if(!found)
		{
			return false;
		}
	}
	return true;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Nullable
public List<Match> findDuplicatesSignature(final PsiMethod method, ParametersFolder folder) {
  final List<PsiExpression> copies = new ArrayList<PsiExpression>();
  final InputVariables variables = detectTopLevelExpressionsToReplaceWithParameters(copies);
  if (variables == null) {
    return null;
  }

  final DuplicatesFinder defaultFinder = MethodDuplicatesHandler.createDuplicatesFinder(myExtractedMethod);
  if (defaultFinder == null) {
    return null; 
  }

  final DuplicatesFinder finder = new DuplicatesFinder(defaultFinder.getPattern(), variables, defaultFinder.getReturnValue(), new ArrayList<PsiVariable>()) {
    @Override
    protected boolean isSelf(PsiElement candidate) {
      return PsiTreeUtil.isAncestor(method, candidate, true);
    }
  };
  List<Match> duplicates = finder.findDuplicates(method.getContainingClass());

  if (duplicates != null && !duplicates.isEmpty()) {
    restoreRenamedParams(copies, folder);
    if (!myMethodCall.isValid()) {
      return null;
    }
    myMethodCall = (PsiMethodCallExpression)myMethodCall.copy();
    inlineSameArguments(method, copies, variables, duplicates);
    for (PsiExpression expression : copies) {
      myMethodCall.getArgumentList().add(expression);
    }
    return duplicates;
  }
  else {
    return null;
  }
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
private void inlineSameArguments(PsiMethod method, List<PsiExpression> copies, InputVariables variables, List<Match> duplicates) {
  final List<VariableData> variableDatum = variables.getInputVariables();
  final Map<PsiVariable, PsiExpression> toInline = new HashMap<PsiVariable, PsiExpression>();
  final int strongParamsCound = method.getParameterList().getParametersCount();
  for (int i = strongParamsCound; i < variableDatum.size(); i++) {
    VariableData variableData = variableDatum.get(i);
    final THashSet<PsiExpression> map = new THashSet<PsiExpression>(ourEquivalenceStrategy);
    if (!collectParamValues(duplicates, variableData, map)) {
      continue;
    }

    final PsiExpression currentExpression = copies.get(i - strongParamsCound);
    map.add(currentExpression);

    if (map.size() == 1) {
      toInline.put(variableData.variable, currentExpression);
    }
  }

  if (!toInline.isEmpty()) {
    copies.removeAll(toInline.values());
    inlineArgumentsInMethodBody(toInline);
    removeRedundantParametersFromMethodSignature(toInline);
  }

  removeUnusedStongParams(strongParamsCound);
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Nullable
private DuplicatesFinder initDuplicates()
{
	List<PsiElement> elements = new ArrayList<PsiElement>();
	for(PsiElement element : myElements)
	{
		if(!(element instanceof PsiWhiteSpace || element instanceof PsiComment))
		{
			elements.add(element);
		}
	}

	if(myExpression != null)
	{
		DuplicatesFinder finder = new DuplicatesFinder(PsiUtilCore.toPsiElementArray(elements), myInputVariables.copy(), new ArrayList<PsiVariable>());
		myDuplicates = finder.findDuplicates(myTargetClass);
		return finder;
	}
	else if(elements.size() > 0)
	{
		DuplicatesFinder myDuplicatesFinder = new DuplicatesFinder(PsiUtilCore.toPsiElementArray(elements), myInputVariables.copy(),
				myOutputVariable != null ? new VariableReturnValue(myOutputVariable) : null, Arrays.asList(myOutputVariables));
		myDuplicates = myDuplicatesFinder.findDuplicates(myTargetClass);
		return myDuplicatesFinder;
	}
	else
	{
		myDuplicates = new ArrayList<Match>();
	}
	return null;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Override
public List<Match> getDuplicates()
{
	if(myIsChainedConstructor)
	{
		return filterChainedConstructorDuplicates(myDuplicates);
	}
	return myDuplicates;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
public List<Match> getDuplicates(final PsiMethod method, final PsiMethodCallExpression methodCall, ParametersFolder folder)
{
	final List<Match> duplicates = findDuplicatesSignature(method, folder);
	if(duplicates != null && !duplicates.isEmpty())
	{
		if(ApplicationManager.getApplication().isUnitTestMode() || new PreviewDialog(method, myExtractedMethod, methodCall, myMethodCall, duplicates.size()).showAndGet())
		{
			PsiDocumentManager.getInstance(myProject).commitAllDocuments();
			WriteCommandAction.runWriteCommandAction(myProject, new Runnable()
			{
				@Override
				public void run()
				{
					myMethodCall = (PsiMethodCallExpression) methodCall.replace(myMethodCall);
					myExtractedMethod = (PsiMethod) method.replace(myExtractedMethod);
				}
			});

			final DuplicatesFinder finder = MethodDuplicatesHandler.createDuplicatesFinder(myExtractedMethod);
			if(finder != null)
			{
				final List<VariableData> datas = finder.getParameters().getInputVariables();
				myVariableData = datas.toArray(new VariableData[datas.size()]);
				return finder.findDuplicates(myExtractedMethod.getContainingClass());
			}
		}
	}
	return null;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
private void inlineSameArguments(PsiMethod method, List<PsiExpression> copies, InputVariables variables, List<Match> duplicates)
{
	final List<VariableData> variableDatum = variables.getInputVariables();
	final Map<PsiVariable, PsiExpression> toInline = new HashMap<PsiVariable, PsiExpression>();
	final int strongParamsCound = method.getParameterList().getParametersCount();
	for(int i = strongParamsCound; i < variableDatum.size(); i++)
	{
		VariableData variableData = variableDatum.get(i);
		final THashSet<PsiExpression> map = new THashSet<PsiExpression>(ourEquivalenceStrategy);
		if(!collectParamValues(duplicates, variableData, map))
		{
			continue;
		}

		final PsiExpression currentExpression = copies.get(i - strongParamsCound);
		map.add(currentExpression);

		if(map.size() == 1)
		{
			toInline.put(variableData.variable, currentExpression);
		}
	}

	if(!toInline.isEmpty())
	{
		copies.removeAll(toInline.values());
		inlineArgumentsInMethodBody(toInline);
		removeRedundantParametersFromMethodSignature(toInline);
	}

	removeUnusedStongParams(strongParamsCound);
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
public static boolean performExtractMethod(boolean doRefactor,
                                           boolean replaceAllDuplicates,
                                           Editor editor,
                                           PsiFile file,
                                           Project project,
                                           final boolean extractChainedConstructor,
                                           PsiType returnType,
                                           boolean makeStatic,
                                           String newNameOfFirstParam,
                                           int... disabledParams)
  throws PrepareFailedException, IncorrectOperationException {
  int startOffset = editor.getSelectionModel().getSelectionStart();
  int endOffset = editor.getSelectionModel().getSelectionEnd();

  PsiElement[] elements;
  PsiExpression expr = CodeInsightUtil.findExpressionInRange(file, startOffset, endOffset);
  if (expr != null) {
    elements = new PsiElement[]{expr};
  }
  else {
    elements = CodeInsightUtil.findStatementsInRange(file, startOffset, endOffset);
  }
  if (elements.length == 0) {
    final PsiExpression expression = IntroduceVariableBase.getSelectedExpression(project, file, startOffset, endOffset);
    if (expression != null) {
      elements = new PsiElement[]{expression};
    }
  }
  assertTrue(elements.length > 0);

  final ExtractMethodProcessor processor =
    new ExtractMethodProcessor(project, editor, elements, null, "Extract Method", "newMethod", null);
  processor.setShowErrorDialogs(false);
  processor.setChainedConstructor(extractChainedConstructor);

  if (!processor.prepare()) {
    return false;
  }

  if (doRefactor) {
    processor.testPrepare(returnType, makeStatic);
    processor.testNullness();
    if (disabledParams != null) {
      for (int param : disabledParams) {
        processor.doNotPassParameter(param);
      }
    }
    if (newNameOfFirstParam != null) {
      processor.changeParamName(0, newNameOfFirstParam);
    }
    ExtractMethodHandler.run(project, editor, processor);
  }

  if (replaceAllDuplicates) {
    final Boolean hasDuplicates = processor.hasDuplicates();
    if (hasDuplicates == null || hasDuplicates.booleanValue()) {
      final List<Match> duplicates = processor.getDuplicates();
      for (final Match match : duplicates) {
        if (!match.getMatchStart().isValid() || !match.getMatchEnd().isValid()) continue;
        PsiDocumentManager.getInstance(project).commitAllDocuments();
        processor.processMatch(match);
      }
    }
  }

  return true;
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
@Override
public void visitTryStatement(PsiTryStatement statement) {
  super.visitTryStatement(statement);
  final PsiCatchSection[] catchSections = statement.getCatchSections();
  if (catchSections.length < 2) {
    return;
  }
  final PsiParameter[] parameters = statement.getCatchBlockParameters();
  if (catchSections.length != parameters.length) {
    return;
  }
  final boolean[] duplicates = new boolean[catchSections.length];
  for (int i = 0; i < catchSections.length - 1; i++) {
    final PsiCatchSection catchSection = catchSections[i];
    final PsiCodeBlock catchBlock = catchSection.getCatchBlock();
    if (catchBlock == null) {
      continue;
    }
    final PsiParameter parameter = catchSection.getParameter();
    if (parameter == null) {
      continue;
    }
    final InputVariables inputVariables = new InputVariables(Collections.singletonList(parameter),
                                                             statement.getProject(),
                                                             new LocalSearchScope(catchBlock),
                                                             false);
    final DuplicatesFinder finder = new DuplicatesFinder(new PsiElement[]{catchBlock},
                                                         inputVariables, null, Collections.<PsiVariable>emptyList());
    for (int j = i + 1; j < catchSections.length; j++) {
      if (duplicates[j]) {
        continue;
      }
      final PsiCatchSection otherSection = catchSections[j];
      final PsiCodeBlock otherCatchBlock = otherSection.getCatchBlock();
      if (otherCatchBlock == null) {
        continue;
      }
      final Match match = finder.isDuplicate(otherCatchBlock, true);
      if (match == null || match.getReturnValue() != null) {
        continue;
      }
      final List<PsiElement> parameterValues = match.getParameterValues(parameter);
      if (parameterValues != null && (parameterValues.size() != 1 || !(parameterValues.get(0) instanceof PsiReferenceExpression))) {
        continue;
      }
      if (j > i ? !canCollapse(parameters, i, j) : !canCollapse(parameters, j, i)) {
        continue;
      }
      final PsiJavaToken rParenth = otherSection.getRParenth();
      if (rParenth != null) {
        registerErrorAtOffset(otherSection, 0, rParenth.getStartOffsetInParent() + 1, parameter.getType(),
                              Integer.valueOf(i), Integer.valueOf(j));
      }
      duplicates[i] = true;
      duplicates[j] = true;
    }
  }
}
 

import com.intellij.refactoring.util.duplicates.Match; //导入依赖的package包/类
public static boolean performExtractMethod(boolean doRefactor,
                                           boolean replaceAllDuplicates,
                                           Editor editor,
                                           PsiFile file,
                                           Project project,
                                           final boolean extractChainedConstructor,
                                           int... disabledParams)
  throws PrepareFailedException, IncorrectOperationException {
  int startOffset = editor.getSelectionModel().getSelectionStart();
  int endOffset = editor.getSelectionModel().getSelectionEnd();

  PsiElement[] elements;
  PsiExpression expr = CodeInsightUtil.findExpressionInRange(file, startOffset, endOffset);
  if (expr != null) {
    elements = new PsiElement[]{expr};
  }
  else {
    elements = CodeInsightUtil.findStatementsInRange(file, startOffset, endOffset);
  }
  if (elements.length == 0) {
    final PsiExpression expression = IntroduceVariableBase.getSelectedExpression(project, file, startOffset, endOffset);
    if (expression != null) {
      elements = new PsiElement[]{expression};
    }
  }
  assertTrue(elements.length > 0);

  final ExtractMethodProcessor processor =
    new ExtractMethodProcessor(project, editor, elements, null, "Extract Method", "newMethod", null);
  processor.setShowErrorDialogs(false);
  processor.setChainedConstructor(extractChainedConstructor);

  if (!processor.prepare()) {
    return false;
  }

  if (doRefactor) {
    processor.testPrepare();
    if (disabledParams != null) {
      for (int param : disabledParams) {
        processor.doNotPassParameter(param);
      }
    }
    ExtractMethodHandler.run(project, editor, processor);
  }

  if (replaceAllDuplicates) {
    final List<Match> duplicates = processor.getDuplicates();
    for (final Match match : duplicates) {
      if (!match.getMatchStart().isValid() || !match.getMatchEnd().isValid()) continue;
      PsiDocumentManager.getInstance(project).commitAllDocuments();
      processor.processMatch(match);
    }
  }

  return true;
}