/**
 * Checks that the slice can be extracted into a separate method without compilation errors.
 */
private boolean canBeExtracted(ASTSlice slice) {
    SmartList<PsiStatement> statementsToExtract = getStatementsToExtract(slice);

    MyExtractMethodProcessor processor = new MyExtractMethodProcessor(scope.getProject(),
            null, statementsToExtract.toArray(new PsiElement[0]), slice.getLocalVariableCriterion().getType(),
            IntelliJDeodorantBundle.message("extract.method.refactoring.name"), "", HelpID.EXTRACT_METHOD,
            slice.getSourceTypeDeclaration(), slice.getLocalVariableCriterion());

    processor.setOutputVariable();

    try {
        processor.setShowErrorDialogs(false);
        return processor.prepare();

    } catch (PrepareFailedException e) {
        e.printStackTrace();
    }
    return false;
}
 

/**
 * Collects statements that can be extracted into a separate method.
 */
public SmartList<PsiStatement> getStatementsToExtract(ASTSlice slice) {
    Set<PDGNode> nodes = slice.getSliceNodes();
    SmartList<PsiStatement> statementsToExtract = new SmartList<>();

    for (PDGNode pdgNode : nodes) {
        boolean isNotChild = true;
        for (PDGNode node : nodes) {
            if (isChild(node.getASTStatement(), pdgNode.getASTStatement())) {
                isNotChild = false;
            }
        }
        if (isNotChild) {
            statementsToExtract.add(pdgNode.getASTStatement());
        }
    }
    return statementsToExtract;
}
 

@Test
public void markStatement() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertThat(psiClasses).hasSize(2);

        PsiClass underTest = psiClasses.get(0);
        PsiClass component = psiClasses.get(1);

        // For testing environment
        Function<PsiMethodCallExpression, PsiClass> resolver = ignored -> component;
        RequiredPropLineMarkerProvider provider = new RequiredPropLineMarkerProvider(resolver);
        List<PsiElement> statements =
            new ArrayList<>(PsiTreeUtil.findChildrenOfAnyType(underTest, PsiStatement.class));

        assertThat(provider.getLineMarkerInfo(statements.get(0))).isNotNull();
        assertThat(provider.getLineMarkerInfo(statements.get(1))).isNull();

        return true;
      },
      "RequiredPropAnnotatorTest.java",
      "RequiredPropAnnotatorComponent.java");
}
 

public static void translate(PsiDeclarationStatement stmt, TranslationContext ctx) {
    for (int i = 0; i < stmt.getDeclaredElements().length; i++) {

        if(i > 0) {
            ctx.append(", ");
        }

        PsiElement element1 = stmt.getDeclaredElements()[i];
        if (element1 instanceof PsiStatement) {
            StatementTranslator.translate((PsiStatement) element1, ctx);
        } else if (element1 instanceof PsiLocalVariable) {
            LocalVariableTranslator.translate((PsiLocalVariable) element1, ctx);
        } else {
            System.err.println("Not managed " + element1);
        }
    }
}
 

/**
 * Extracts statements into new method.
 *
 * @param slice computation slice.
 * @return callback to run when "Refactor" button is selected.
 */
private Runnable doExtract(ASTSlice slice) {
    return () -> {
        Editor editor = FileEditorManager.getInstance(slice.getSourceMethodDeclaration().getProject()).getSelectedTextEditor();
        SmartList<PsiStatement> statementsToExtract = getStatementsToExtract(slice);

        MyExtractMethodProcessor processor = new MyExtractMethodProcessor(slice.getSourceMethodDeclaration().getProject(),
                editor, statementsToExtract.toArray(new PsiElement[0]), slice.getLocalVariableCriterion().getType(),
                "", "", HelpID.EXTRACT_METHOD,
                slice.getSourceTypeDeclaration(), slice.getLocalVariableCriterion());

        processor.setOutputVariable();

        try {
            processor.setShowErrorDialogs(true);
            if (processor.prepare()) {
                ExtractMethodHandler.invokeOnElements(slice.getSourceMethodDeclaration().getProject(), processor,
                        slice.getSourceMethodDeclaration().getContainingFile(), true);
                if (editor != null && processor.getExtractedMethod() != null) {
                    IntelliJDeodorantCounterCollector.getInstance().extractMethodRefactoringApplied(editor.getProject(),
                            slice, processor.getExtractedMethod());
                }
            }
        } catch (PrepareFailedException e) {
            e.printStackTrace();
        }
    };
}
 

/**
 * Opens definition of method and highlights statements, which should be extracted.
 *
 * @param sourceMethod method from which code is proposed to be extracted into separate method.
 * @param scope        scope of the current project.
 * @param slice        computation slice.
 */
private static void openDefinition(@Nullable PsiMethod sourceMethod, AnalysisScope scope, ASTSlice slice) {
    new Task.Backgroundable(scope.getProject(), "Search Definition") {
        @Override
        public void run(@NotNull ProgressIndicator indicator) {
            indicator.setIndeterminate(true);
        }

        @Override
        public void onSuccess() {
            if (sourceMethod != null) {
                Set<SmartPsiElementPointer<PsiElement>> statements = slice.getSliceStatements();
                PsiStatement psiStatement = (PsiStatement) statements.iterator().next().getElement();
                if (psiStatement != null && psiStatement.isValid()) {
                    EditorHelper.openInEditor(psiStatement);
                    Editor editor = FileEditorManager.getInstance(sourceMethod.getProject()).getSelectedTextEditor();
                    if (editor != null) {
                        TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
                        editor.getMarkupModel().removeAllHighlighters();
                        statements.stream()
                                .filter(statement -> statement.getElement() != null)
                                .forEach(statement ->
                                        editor.getMarkupModel().addRangeHighlighter(statement.getElement().getTextRange().getStartOffset(),
                                                statement.getElement().getTextRange().getEndOffset(), HighlighterLayer.SELECTION,
                                                attributes, HighlighterTargetArea.EXACT_RANGE));
                    }
                }
            }
        }
    }.queue();
}
 

public boolean instanceOf(PsiStatement statement) {
    if (statement instanceof PsiDeclarationStatement) {
        PsiDeclarationStatement declarationStatement = (PsiDeclarationStatement) statement;
        PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
        for (PsiElement element : declaredElements) {
            if (element instanceof PsiVariable) {
                return true;
            }
        }
    }
    return false;
}
 

PsiStatement getASTStatement() {
    if (statement.getStatement() instanceof PsiStatement) {
        return (PsiStatement) statement.getStatement();
    } else {
        return null;
    }
}
 

public PsiElement getStatement() {
    PsiElement element = this.statement.getElement();
    if (element instanceof PsiStatement || element instanceof PsiCodeBlock) {
        return element;
    } else {
        return null;
    }
}
 

@Test
public void annotateStatement() {
  testHelper.getPsiClass(
      psiClasses -> {
        assertEquals(2, psiClasses.size());

        PsiClass underTest = psiClasses.get(0);
        PsiClass component = psiClasses.get(1);

        // For testing environment
        Function<PsiMethodCallExpression, PsiClass> resolver =
            psiMethodCallExpression -> component;
        RequiredPropAnnotator annotator = new RequiredPropAnnotator(resolver);
        TestHolder holder = new TestHolder();
        Collection<PsiStatement> statements =
            PsiTreeUtil.findChildrenOfAnyType(underTest, PsiStatement.class);
        // Simulates IDE behavior of traversing Psi elements
        for (PsiStatement statement : statements) {
          annotator.annotate(statement, holder);
        }

        assertEquals(3, holder.errorMessages.size());
        for (String errorMessage : holder.errorMessages) {
          assertEquals(
              "The following props are not "
                  + "marked as optional and were not supplied: testRequiredPropName",
              errorMessage);
        }
        assertEquals(3, holder.errorElements.size());
        for (PsiElement errorElement : holder.errorElements) {
          assertEquals("RequiredPropAnnotatorComponent.create", errorElement.getText());
        }
        return true;
      },
      "RequiredPropAnnotatorTest.java",
      "RequiredPropAnnotatorComponent.java");
}
 

public static void translate(PsiCodeBlock block, TranslationContext ctx) {
    ctx.append("{\n");
    ctx.increaseIdent();
    for (PsiStatement statement : block.getStatements()) {
        StatementTranslator.translate(statement, ctx);
    }
    ctx.decreaseIdent();
    ctx.print("}");
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiForStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiDoWhileStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiSwitchStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiContinueStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
    return statement instanceof PsiBreakStatement || statement instanceof PsiContinueStatement
            || statement instanceof PsiReturnStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiReturnStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiIfStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiForeachStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiWhileStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiBreakStatement;
}
 

public boolean instanceOf(PsiStatement statement) {
	return statement instanceof PsiTryStatement;
}
 

SynchronizedStatementObject(PsiStatement statement, AbstractMethodFragment parent) {
    super(statement, StatementType.SYNCHRONIZED, parent);
    AbstractExpression abstractExpression = new AbstractExpression(
            ((PsiSynchronizedStatement) statement).getLockExpression(), this);
    this.addExpression(abstractExpression);
}
 

public TryStatementObject(PsiStatement statement, AbstractMethodFragment parent) {
    super(statement, StatementType.TRY, parent);
    this.catchClauses = new SmartList<>();
}
 

@NotNull
@Override
public PsiStatement[] getStatements() {
  // TODO: Implement
  return new PsiStatement[0];
}
 

static PsiStatement createReturnThis(@NotNull PsiElementFactory psiElementFactory, @Nullable PsiElement context) {
    return psiElementFactory.createStatementFromText("return this;", context);
}
 

boolean instanceOf(PsiStatement statement);