protected static void addStatementBefore(String newStatementText, PsiReturnStatement anchor) {
final Project project = anchor.getProject();
final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
final PsiStatement newStatement = factory.createStatementFromText(newStatementText, anchor);
final PsiElement addedStatement = anchor.getParent().addBefore(newStatement, anchor);
CodeStyleManager.getInstance(project).reformat(addedStatement);
}
@Override
public void invoke(
@NotNull Project project,
@NotNull PsiFile file,
Editor editor,
@NotNull PsiElement startElement,
@NotNull PsiElement endElement) {
final PsiMethod myMethod = (PsiMethod) startElement;
if (!FileModificationService.getInstance().prepareFileForWrite(myMethod.getContainingFile()))
return;
final PsiType myReturnType = myReturnTypePointer.getType();
if (myReturnType == null) return;
if (myFixWholeHierarchy) {
final PsiMethod superMethod = myMethod.findDeepestSuperMethod();
final PsiType superReturnType = superMethod == null ? null : superMethod.getReturnType();
if (superReturnType != null
&& !Comparing.equal(myReturnType, superReturnType)
&& !changeClassTypeArgument(
myMethod,
project,
superReturnType,
superMethod.getContainingClass(),
editor,
myReturnType)) {
return;
}
}
final List<PsiMethod> affectedMethods = changeReturnType(myMethod, myReturnType);
PsiElementFactory factory = JavaPsiFacade.getInstance(project).getElementFactory();
PsiReturnStatement statementToSelect = null;
if (!PsiType.VOID.equals(myReturnType)) {
final ReturnStatementAdder adder = new ReturnStatementAdder(factory, myReturnType);
for (PsiMethod affectedMethod : affectedMethods) {
PsiReturnStatement statement = adder.addReturnForMethod(file, affectedMethod);
if (statement != null && affectedMethod == myMethod) {
statementToSelect = statement;
}
}
}
if (statementToSelect != null) {
Editor editorForMethod =
getEditorForMethod(myMethod, project, editor, statementToSelect.getContainingFile());
if (editorForMethod != null) {
selectReturnValueInEditor(statementToSelect, editorForMethod);
}
}
}
public static List<PsiExpression> getReturnExpressions(PsiLambdaExpression lambdaExpression) {
final PsiElement body = lambdaExpression.getBody();
if (body instanceof PsiExpression) {
// if (((PsiExpression)body).getType() != PsiType.VOID) return Collections.emptyList();
return Collections.singletonList((PsiExpression) body);
}
final List<PsiExpression> result = new ArrayList<PsiExpression>();
for (PsiReturnStatement returnStatement : getReturnStatements(lambdaExpression)) {
final PsiExpression returnValue = returnStatement.getReturnValue();
if (returnValue != null) {
result.add(returnValue);
}
}
return result;
}
static void selectReturnValueInEditor(
final PsiReturnStatement returnStatement, final Editor editor) {
TextRange range = returnStatement.getReturnValue().getTextRange();
int offset = range.getStartOffset();
editor.getCaretModel().moveToOffset(offset);
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
editor.getSelectionModel().setSelection(range.getEndOffset(), range.getStartOffset());
}
@Override
public void visitReturnStatement(@NotNull PsiReturnStatement returnStatement) {
if (read || written) {
return;
}
super.visitReturnStatement(returnStatement);
final PsiExpression returnValue = returnStatement.getReturnValue();
if (returnValue == null) {
return;
}
final VariableUsedVisitor visitor = new VariableUsedVisitor(variable);
returnValue.accept(visitor);
read = visitor.isUsed();
reference = visitor.getReference();
}
private static boolean returnStatementsAreEquivalent(
@NotNull PsiReturnStatement statement1, @NotNull PsiReturnStatement statement2) {
final PsiExpression returnValue1 = statement1.getReturnValue();
final PsiExpression returnValue2 = statement2.getReturnValue();
return expressionsAreEquivalent(returnValue1, returnValue2);
}
protected void generateFindViewById() {
PsiClass activityClass =
JavaPsiFacade.getInstance(mProject)
.findClass("android.app.Activity", new EverythingGlobalScope(mProject));
PsiClass compatActivityClass =
JavaPsiFacade.getInstance(mProject)
.findClass(
"android.support.v7.app.AppCompatActivity", new EverythingGlobalScope(mProject));
PsiClass fragmentClass =
JavaPsiFacade.getInstance(mProject)
.findClass("android.app.Fragment", new EverythingGlobalScope(mProject));
PsiClass supportFragmentClass =
JavaPsiFacade.getInstance(mProject)
.findClass("android.support.v4.app.Fragment", new EverythingGlobalScope(mProject));
// Check for Activity class
if ((activityClass != null && mClass.isInheritor(activityClass, true))
|| (compatActivityClass != null && mClass.isInheritor(compatActivityClass, true))
|| mClass.getName().contains("Activity")) {
if (mClass.findMethodsByName("onCreate", false).length == 0) {
// Add an empty stub of onCreate()
StringBuilder method = new StringBuilder();
method.append(
"@Override protected void onCreate(android.os.Bundle savedInstanceState) {\n");
method.append("super.onCreate(savedInstanceState);\n");
method.append("\t// TODO: add setContentView(...) and run LayoutCreator again\n");
method.append("}");
mClass.add(mFactory.createMethodFromText(method.toString(), mClass));
} else {
PsiStatement setContentViewStatement = null;
boolean hasInitViewStatement = false;
PsiMethod onCreate = mClass.findMethodsByName("onCreate", false)[0];
for (PsiStatement statement : onCreate.getBody().getStatements()) {
// Search for setContentView()
if (statement.getFirstChild() instanceof PsiMethodCallExpression) {
PsiReferenceExpression methodExpression =
((PsiMethodCallExpression) statement.getFirstChild()).getMethodExpression();
if (methodExpression.getText().equals("setContentView")) {
setContentViewStatement = statement;
} else if (methodExpression.getText().equals("initView")) {
hasInitViewStatement = true;
}
}
}
if (!hasInitViewStatement && setContentViewStatement != null) {
// Insert initView() after setContentView()
onCreate
.getBody()
.addAfter(
mFactory.createStatementFromText("initView();", mClass), setContentViewStatement);
}
generatorLayoutCode("this", null);
}
// Check for Fragment class
} else if ((fragmentClass != null && mClass.isInheritor(fragmentClass, true))
|| (supportFragmentClass != null && mClass.isInheritor(supportFragmentClass, true))) {
if (mClass.findMethodsByName("onCreateView", false).length == 0) {
// Add an empty stub of onCreateView()
StringBuilder method = new StringBuilder();
method.append(
"@Override public View onCreateView(android.view.LayoutInflater inflater, android.view.ViewGroup container, android.os.Bundle savedInstanceState) {\n");
method.append(
"\t// TODO: inflate a fragment like bottom ... and run LayoutCreator again\n");
method.append("View view = View.inflate(getActivity(), R.layout.frag_layout, null);");
method.append("return view;");
method.append("}");
mClass.add(mFactory.createMethodFromText(method.toString(), mClass));
} else {
PsiReturnStatement returnStatement = null;
String returnValue = null;
boolean hasInitViewStatement = false;
PsiMethod onCreateView = mClass.findMethodsByName("onCreateView", false)[0];
for (PsiStatement statement : onCreateView.getBody().getStatements()) {
if (statement instanceof PsiReturnStatement) {
returnStatement = (PsiReturnStatement) statement;
returnValue = returnStatement.getReturnValue().getText();
} else if (statement.getFirstChild() instanceof PsiMethodCallExpression) {
PsiReferenceExpression methodExpression =
((PsiMethodCallExpression) statement.getFirstChild()).getMethodExpression();
if (methodExpression.getText().equals("initView")) {
hasInitViewStatement = true;
}
}
}
if (!hasInitViewStatement && returnStatement != null && returnValue != null) {
// Insert initView() before return statement
onCreateView
.getBody()
.addBefore(
mFactory.createStatementFromText("initView(" + returnValue + ");", mClass),
returnStatement);
}
generatorLayoutCode("getContext()", returnValue);
}
}
}
