azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

OverrideImplementMethodsHandler: J2K

Browse Source
This commit is contained in:
Dmitry Jemerov
2015-04-24 14:05:58 +02:00
parent 5ba89206b7
commit e9c669c841
3 changed files with 262 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-analysis/src/org/jetbrains/kotlin/idea/quickfix/generateUtil.kt
+1 -1
View File
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.psi.JetWithExpressionInitializer
import org.jetbrains.kotlin.psi.JetProperty import org.jetbrains.kotlin.psi.JetProperty
import org.jetbrains.kotlin.psi.psiUtil.siblings import org.jetbrains.kotlin.psi.psiUtil.siblings
private fun moveCaretIntoGeneratedElement(editor: Editor, element: PsiElement): Boolean { public fun moveCaretIntoGeneratedElement(editor: Editor, element: PsiElement): Boolean {
// Inspired by GenerateMembersUtils.positionCaret() // Inspired by GenerateMembersUtils.positionCaret()
if (element is JetDeclarationWithBody && element.hasBody()) { if (element is JetDeclarationWithBody && element.hasBody()) {
idea/idea-core/src/org/jetbrains/kotlin/idea/core/codeInsight/OverrideImplementMethodsHandler.kt
+208 -249
View File
@@ -14,339 +14,298 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.core.codeInsight; package org.jetbrains.kotlin.idea.core.codeInsight
import com.intellij.codeInsight.hint.HintManager; import com.intellij.codeInsight.hint.HintManager
import com.intellij.ide.util.MemberChooser; import com.intellij.ide.util.MemberChooser
import com.intellij.lang.ASTNode; import com.intellij.lang.ASTNode
import com.intellij.lang.LanguageCodeInsightActionHandler; import com.intellij.lang.LanguageCodeInsightActionHandler
import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.editor.Editor; import com.intellij.openapi.editor.Editor
import com.intellij.openapi.project.Project; import com.intellij.openapi.project.Project
import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.ui.DialogWrapper
import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Condition
import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.util.text.StringUtil
import com.intellij.psi.*; import com.intellij.psi.*
import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.idea.caches.resolve.*
import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage; import org.jetbrains.kotlin.idea.quickfix.*
import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde; import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
import org.jetbrains.kotlin.idea.quickfix.QuickfixPackage; import org.jetbrains.kotlin.idea.util.ShortenReferences
import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers; import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.idea.util.ShortenReferences; import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.renderer.DescriptorRendererBuilder
import org.jetbrains.kotlin.renderer.DescriptorRenderer; import org.jetbrains.kotlin.renderer.NameShortness
import org.jetbrains.kotlin.renderer.DescriptorRendererBuilder; import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.renderer.NameShortness;
import org.jetbrains.kotlin.types.JetType;
import java.util.ArrayList; import java.util.ArrayList
import java.util.Collections; import java.util.Collections
import java.util.List;
import java.util.Set;
import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; import org.jetbrains.kotlin.psi.JetPsiFactory
public abstract class OverrideImplementMethodsHandler implements LanguageCodeInsightActionHandler { public abstract class OverrideImplementMethodsHandler : LanguageCodeInsightActionHandler {
private static final DescriptorRenderer OVERRIDE_RENDERER = new DescriptorRendererBuilder() public fun collectMethodsToGenerate(classOrObject: JetClassOrObject): Set<CallableMemberDescriptor> {
.setRenderDefaultValues(false) val descriptor = classOrObject.resolveToDescriptor()
.setModifiers(DescriptorRenderer.Modifier.OVERRIDE) if (descriptor is ClassDescriptor) {
.setWithDefinedIn(false) return collectMethodsToGenerate(descriptor)
.setNameShortness(NameShortness.SOURCE_CODE_QUALIFIED) }
.setOverrideRenderingPolicy(DescriptorRenderer.OverrideRenderingPolicy.RENDER_OVERRIDE) return emptySet()
.setUnitReturnType(false) }
.setTypeNormalizer(IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES)
.build();
private static final Logger LOG = Logger.getInstance(OverrideImplementMethodsHandler.class.getCanonicalName()); protected abstract fun collectMethodsToGenerate(descriptor: ClassDescriptor): Set<CallableMemberDescriptor>
public static List<DescriptorClassMember> membersFromDescriptors( private fun showOverrideImplementChooser(project: Project, members: Array<DescriptorClassMember>): MemberChooser<DescriptorClassMember>? {
JetFile file, Iterable<CallableMemberDescriptor> missingImplementations val chooser = MemberChooser(members, true, true, project)
) { chooser.setTitle(getChooserTitle())
List<DescriptorClassMember> members = new ArrayList<DescriptorClassMember>(); chooser.show()
for (CallableMemberDescriptor memberDescriptor : missingImplementations) { if (chooser.getExitCode() != DialogWrapper.OK_EXIT_CODE) return null
PsiElement declaration = DescriptorToSourceUtilsIde.INSTANCE$.getAnyDeclaration(file.getProject(), memberDescriptor); return chooser
if (declaration == null) { }
LOG.error("Can not find declaration for descriptor " + memberDescriptor);
protected abstract fun getChooserTitle(): String
override fun isValidFor(editor: Editor, file: PsiFile): Boolean {
if (file !is JetFile) {
return false
}
val elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset())
val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(elementAtCaret, javaClass<JetClassOrObject>())
return classOrObject != null
}
protected abstract fun getNoMethodsFoundHint(): String
public fun invoke(project: Project, editor: Editor, file: PsiFile, implementAll: Boolean) {
val elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset())
val classOrObject = PsiTreeUtil.getParentOfType<JetClassOrObject>(elementAtCaret, javaClass<JetClassOrObject>())
assert(classOrObject != null)
val missingImplementations = collectMethodsToGenerate(classOrObject)
if (missingImplementations.isEmpty() && !implementAll) {
HintManager.getInstance().showErrorHint(editor, getNoMethodsFoundHint())
return
}
val members = membersFromDescriptors(file as JetFile, missingImplementations)
val selectedElements: List<DescriptorClassMember>?
if (implementAll) {
selectedElements = members
} }
else { else {
DescriptorClassMember member = new DescriptorClassMember(declaration, memberDescriptor); val chooser = showOverrideImplementChooser(project, members.toTypedArray())
members.add(member);
} if (chooser == null) {
} return
return members;
} }
public static void generateMethods( selectedElements = chooser.getSelectedElements()
@NotNull final Editor editor, if (selectedElements == null || selectedElements.isEmpty()) return
@NotNull final JetClassOrObject classOrObject, }
@NotNull final List<DescriptorClassMember> selectedElements
) { PsiDocumentManager.getInstance(project).commitAllDocuments()
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override generateMethods(editor, classOrObject, selectedElements)
public void run() { }
JetClassBody body = classOrObject.getBody();
override fun invoke(project: Project, editor: Editor, file: PsiFile) {
invoke(project, editor, file, false)
}
override fun startInWriteAction(): Boolean {
return false
}
companion object {
private val OVERRIDE_RENDERER = DescriptorRendererBuilder().setRenderDefaultValues(false).setModifiers(DescriptorRenderer.Modifier.OVERRIDE).setWithDefinedIn(false).setNameShortness(NameShortness.SOURCE_CODE_QUALIFIED).setOverrideRenderingPolicy(DescriptorRenderer.OverrideRenderingPolicy.RENDER_OVERRIDE).setUnitReturnType(false).setTypeNormalizer(IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES).build()
private val LOG = Logger.getInstance(javaClass<OverrideImplementMethodsHandler>().getCanonicalName())
public fun membersFromDescriptors(file: JetFile, missingImplementations: Iterable<CallableMemberDescriptor>): List<DescriptorClassMember> {
val members = ArrayList<DescriptorClassMember>()
for (memberDescriptor in missingImplementations) {
val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(file.getProject(), memberDescriptor)
if (declaration == null) {
LOG.error("Can not find declaration for descriptor " + memberDescriptor)
}
else {
val member = DescriptorClassMember(declaration, memberDescriptor)
members.add(member)
}
}
return members
}
public fun generateMethods(editor: Editor, classOrObject: JetClassOrObject, selectedElements: List<DescriptorClassMember>) {
ApplicationManager.getApplication().runWriteAction(object : Runnable {
override fun run() {
var body = classOrObject.getBody()
if (body == null) { if (body == null) {
JetPsiFactory psiFactory = JetPsiFactory(classOrObject); val psiFactory = JetPsiFactory(classOrObject)
classOrObject.add(psiFactory.createWhiteSpace()); classOrObject.add(psiFactory.createWhiteSpace())
body = (JetClassBody) classOrObject.add(psiFactory.createEmptyClassBody()); body = classOrObject.add(psiFactory.createEmptyClassBody()) as JetClassBody
} }
PsiElement afterAnchor = findInsertAfterAnchor(editor, body); var afterAnchor = findInsertAfterAnchor(editor, body)
if (afterAnchor == null) return; if (afterAnchor == null) return
PsiElement firstGenerated = null; var firstGenerated: PsiElement? = null
List<JetElement> elementsToCompact = new ArrayList<JetElement>(); val elementsToCompact = ArrayList<JetElement>()
for (JetElement element : generateOverridingMembers(selectedElements, classOrObject)) { for (element in generateOverridingMembers(selectedElements, classOrObject)) {
PsiElement added = body.addAfter(element, afterAnchor); val added = body!!.addAfter(element, afterAnchor)
if (firstGenerated == null) { if (firstGenerated == null) {
firstGenerated = added; firstGenerated = added
} }
afterAnchor = added; afterAnchor = added
elementsToCompact.add((JetElement) added); elementsToCompact.add(added as JetElement)
} }
ShortenReferences.DEFAULT.process(elementsToCompact); ShortenReferences.DEFAULT.process(elementsToCompact)
if (firstGenerated == null) return; if (firstGenerated == null) return
Project project = classOrObject.getProject(); val project = classOrObject.getProject()
SmartPsiElementPointer<PsiElement> pointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(firstGenerated); val pointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer<PsiElement>(firstGenerated)
PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument()); PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument())
PsiElement element = pointer.getElement(); val element = pointer.getElement()
if (element != null) { if (element != null) {
QuickfixPackage.moveCaretIntoGeneratedElement(editor, element); moveCaretIntoGeneratedElement(editor, element)
} }
} }
}); })
} }
@Nullable private fun findInsertAfterAnchor(editor: Editor, body: JetClassBody): PsiElement? {
private static PsiElement findInsertAfterAnchor(Editor editor, final JetClassBody body) { val afterAnchor = body.getLBrace()
PsiElement afterAnchor = body.getLBrace(); if (afterAnchor == null) return null
if (afterAnchor == null) return null;
int offset = editor.getCaretModel().getOffset(); val offset = editor.getCaretModel().getOffset()
PsiElement offsetCursorElement = PsiTreeUtil.findFirstParent( val offsetCursorElement = PsiTreeUtil.findFirstParent(body.getContainingFile().findElementAt(offset), object : Condition<PsiElement> {
body.getContainingFile().findElementAt(offset), override fun value(element: PsiElement): Boolean {
new Condition<PsiElement>() { return element.getParent() == body
@Override
public boolean value(PsiElement element) {
return element.getParent() == body;
} }
}); })
if (offsetCursorElement instanceof PsiWhiteSpace) { if (offsetCursorElement is PsiWhiteSpace) {
return removeAfterOffset(offset, (PsiWhiteSpace) offsetCursorElement); return removeAfterOffset(offset, offsetCursorElement)
} }
if (offsetCursorElement != null && offsetCursorElement != body.getRBrace()) { if (offsetCursorElement != null && offsetCursorElement != body.getRBrace()) {
return offsetCursorElement; return offsetCursorElement
} }
return afterAnchor; return afterAnchor
} }
private static PsiElement removeAfterOffset(int offset, PsiWhiteSpace whiteSpace) { private fun removeAfterOffset(offset: Int, whiteSpace: PsiWhiteSpace): PsiElement {
ASTNode spaceNode = whiteSpace.getNode(); val spaceNode = whiteSpace.getNode()
if (spaceNode.getTextRange().contains(offset)) { if (spaceNode.getTextRange().contains(offset)) {
String beforeWhiteSpaceText = spaceNode.getText().substring(0, offset - spaceNode.getStartOffset()); var beforeWhiteSpaceText = spaceNode.getText().substring(0, offset - spaceNode.getStartOffset())
if (!StringUtil.containsLineBreak(beforeWhiteSpaceText)) { if (!StringUtil.containsLineBreak(beforeWhiteSpaceText)) {
// Prevent insertion on same line // Prevent insertion on same line
beforeWhiteSpaceText += "\n"; beforeWhiteSpaceText += "\n"
} }
JetPsiFactory factory = JetPsiFactory(whiteSpace.getProject()); val factory = JetPsiFactory(whiteSpace.getProject())
PsiElement insertAfter = whiteSpace.getPrevSibling(); val insertAfter = whiteSpace.getPrevSibling()
whiteSpace.delete(); whiteSpace.delete()
PsiElement beforeSpace = factory.createWhiteSpace(beforeWhiteSpaceText); val beforeSpace = factory.createWhiteSpace(beforeWhiteSpaceText)
insertAfter.getParent().addAfter(beforeSpace, insertAfter); insertAfter.getParent().addAfter(beforeSpace, insertAfter)
return insertAfter.getNextSibling(); return insertAfter.getNextSibling()
} }
return whiteSpace; return whiteSpace
} }
private static List<JetElement> generateOverridingMembers(List<DescriptorClassMember> selectedElements, JetClassOrObject classOrObject) { private fun generateOverridingMembers(selectedElements: List<DescriptorClassMember>, classOrObject: JetClassOrObject): List<JetElement> {
List<JetElement> overridingMembers = new ArrayList<JetElement>(); val overridingMembers = ArrayList<JetElement>()
for (DescriptorClassMember selectedElement : selectedElements) { for (selectedElement in selectedElements) {
DeclarationDescriptor descriptor = selectedElement.getDescriptor(); val descriptor = selectedElement.getDescriptor()
if (descriptor instanceof SimpleFunctionDescriptor) { if (descriptor is SimpleFunctionDescriptor) {
overridingMembers.add(overrideFunction(classOrObject, (SimpleFunctionDescriptor) descriptor)); overridingMembers.add(overrideFunction(classOrObject, descriptor))
} }
else if (descriptor instanceof PropertyDescriptor) { else if (descriptor is PropertyDescriptor) {
overridingMembers.add(overrideProperty(classOrObject, (PropertyDescriptor) descriptor)); overridingMembers.add(overrideProperty(classOrObject, descriptor))
} }
} }
return overridingMembers; return overridingMembers
} }
@NotNull private fun overrideProperty(classOrObject: JetClassOrObject, descriptor: PropertyDescriptor): JetElement {
private static JetElement overrideProperty(@NotNull JetClassOrObject classOrObject, @NotNull PropertyDescriptor descriptor) { val newDescriptor = descriptor.copy(descriptor.getContainingDeclaration(), Modality.OPEN, descriptor.getVisibility(), descriptor.getKind(), /* copyOverrides = */ true) as PropertyDescriptor
PropertyDescriptor newDescriptor = (PropertyDescriptor) descriptor.copy( newDescriptor.addOverriddenDescriptor(descriptor)
descriptor.getContainingDeclaration(),
Modality.OPEN,
descriptor.getVisibility(),
descriptor.getKind(),
/* copyOverrides = */ true);
newDescriptor.addOverriddenDescriptor(descriptor);
StringBuilder body = new StringBuilder(); val body = StringBuilder()
body.append("\nget()"); body.append("\nget()")
body.append(" = "); body.append(" = ")
body.append(generateUnsupportedOrSuperCall(classOrObject, descriptor)); body.append(generateUnsupportedOrSuperCall(classOrObject, descriptor))
if (descriptor.isVar()) { if (descriptor.isVar()) {
body.append("\nset(value) {}"); body.append("\nset(value) {}")
} }
return JetPsiFactory(classOrObject.getProject()).createProperty(OVERRIDE_RENDERER.render(newDescriptor) + body); return JetPsiFactory(classOrObject.getProject()).createProperty(OVERRIDE_RENDERER.render(newDescriptor) + body)
} }
@NotNull private fun overrideFunction(classOrObject: JetClassOrObject, descriptor: FunctionDescriptor): JetNamedFunction {
private static JetNamedFunction overrideFunction(@NotNull JetClassOrObject classOrObject, @NotNull FunctionDescriptor descriptor) { val newDescriptor = descriptor.copy(descriptor.getContainingDeclaration(), Modality.OPEN, descriptor.getVisibility(), descriptor.getKind(), /* copyOverrides = */ true)
FunctionDescriptor newDescriptor = descriptor.copy( newDescriptor.addOverriddenDescriptor(descriptor)
descriptor.getContainingDeclaration(),
Modality.OPEN,
descriptor.getVisibility(),
descriptor.getKind(),
/* copyOverrides = */ true);
newDescriptor.addOverriddenDescriptor(descriptor);
JetType returnType = descriptor.getReturnType(); val returnType = descriptor.getReturnType()
KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); val builtIns = KotlinBuiltIns.getInstance()
boolean returnsNotUnit = returnType != null && !builtIns.getUnitType().equals(returnType); val returnsNotUnit = returnType != null && builtIns.getUnitType() != returnType
boolean isAbstract = descriptor.getModality() == Modality.ABSTRACT; val isAbstract = descriptor.getModality() == Modality.ABSTRACT
String delegation = generateUnsupportedOrSuperCall(classOrObject, descriptor); val delegation = generateUnsupportedOrSuperCall(classOrObject, descriptor)
String body = "{" + (returnsNotUnit && !isAbstract ? "return " : "") + delegation + "}"; val body = "{" + (if (returnsNotUnit && !isAbstract) "return " else "") + delegation + "}"
return JetPsiFactory(classOrObject.getProject()).createFunction(OVERRIDE_RENDERER.render(newDescriptor) + body); return JetPsiFactory(classOrObject.getProject()).createFunction(OVERRIDE_RENDERER.render(newDescriptor) + body)
} }
private static String generateUnsupportedOrSuperCall(@NotNull JetClassOrObject classOrObject, @NotNull CallableMemberDescriptor descriptor) { private fun generateUnsupportedOrSuperCall(classOrObject: JetClassOrObject, descriptor: CallableMemberDescriptor): String {
boolean isAbstract = descriptor.getModality() == Modality.ABSTRACT; val isAbstract = descriptor.getModality() == Modality.ABSTRACT
if (isAbstract) { if (isAbstract) {
return "throw UnsupportedOperationException()"; return "throw UnsupportedOperationException()"
} }
else { else {
StringBuilder builder = new StringBuilder(); val builder = StringBuilder()
builder.append("super"); builder.append("super")
if (classOrObject.getDelegationSpecifiers().size() > 1) { if (classOrObject.getDelegationSpecifiers().size() > 1) {
builder.append("<").append(DescriptorRenderer.COMPACT.renderName(descriptor.getContainingDeclaration().getName())).append(">"); builder.append("<").append(DescriptorRenderer.COMPACT.renderName(descriptor.getContainingDeclaration().getName())).append(">")
} }
builder.append(".").append(DescriptorRenderer.COMPACT.renderName(descriptor.getName())); builder.append(".").append(DescriptorRenderer.COMPACT.renderName(descriptor.getName()))
if (descriptor instanceof FunctionDescriptor) { if (descriptor is FunctionDescriptor) {
builder.append("("); builder.append("(")
boolean first = true; var first = true
for (ValueParameterDescriptor parameterDescriptor : descriptor.getValueParameters()) { for (parameterDescriptor in descriptor.getValueParameters()) {
if (!first) { if (!first) {
builder.append(", "); builder.append(", ")
} }
first = false; first = false
builder.append(DescriptorRenderer.COMPACT.renderName(parameterDescriptor.getName())); builder.append(DescriptorRenderer.COMPACT.renderName(parameterDescriptor.getName()))
} }
builder.append(")"); builder.append(")")
} }
return builder.toString(); return builder.toString()
} }
} }
@NotNull
public Set<CallableMemberDescriptor> collectMethodsToGenerate(@NotNull JetClassOrObject classOrObject) {
DeclarationDescriptor descriptor = ResolvePackage.resolveToDescriptor(classOrObject);
if (descriptor instanceof ClassDescriptor) {
return collectMethodsToGenerate((ClassDescriptor) descriptor);
}
return Collections.emptySet();
}
protected abstract Set<CallableMemberDescriptor> collectMethodsToGenerate(@NotNull ClassDescriptor descriptor);
private MemberChooser<DescriptorClassMember> showOverrideImplementChooser(
Project project,
DescriptorClassMember[] members
) {
MemberChooser<DescriptorClassMember> chooser = new MemberChooser<DescriptorClassMember>(members, true, true, project);
chooser.setTitle(getChooserTitle());
chooser.show();
if (chooser.getExitCode() != DialogWrapper.OK_EXIT_CODE) return null;
return chooser;
}
protected abstract String getChooserTitle();
@Override
public boolean isValidFor(Editor editor, PsiFile file) {
if (!(file instanceof JetFile)) {
return false;
}
PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset());
JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, JetClassOrObject.class);
return classOrObject != null;
}
protected abstract String getNoMethodsFoundHint();
public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file, boolean implementAll) {
PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset());
JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, JetClassOrObject.class);
assert classOrObject != null;
Set<CallableMemberDescriptor> missingImplementations = collectMethodsToGenerate(classOrObject);
if (missingImplementations.isEmpty() && !implementAll) {
HintManager.getInstance().showErrorHint(editor, getNoMethodsFoundHint());
return;
}
List<DescriptorClassMember> members = membersFromDescriptors((JetFile) file, missingImplementations);
List<DescriptorClassMember> selectedElements;
if (implementAll) {
selectedElements = members;
}
else {
MemberChooser<DescriptorClassMember> chooser = showOverrideImplementChooser(
project,
members.toArray(new DescriptorClassMember[members.size()]));
if (chooser == null) {
return;
}
selectedElements = chooser.getSelectedElements();
if (selectedElements == null || selectedElements.isEmpty()) return;
}
PsiDocumentManager.getInstance(project).commitAllDocuments();
generateMethods(editor, classOrObject, selectedElements);
}
@Override
public void invoke(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
invoke(project, editor, file, false);
}
@Override
public boolean startInWriteAction() {
return false;
} }
} }
idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractOverrideImplementTest.java
+3 -3
View File
@@ -164,7 +164,7 @@ public abstract class AbstractOverrideImplementTest extends JetLightCodeInsightF
} }
performGenerateCommand(classOrObject, performGenerateCommand(classOrObject,
OverrideImplementMethodsHandler.membersFromDescriptors(jetFile, Collections.singletonList(singleToOverride))); OverrideImplementMethodsHandler.Companion.membersFromDescriptors(jetFile, Collections.singletonList(singleToOverride)));
} }
private void doMultiOverrideImplement(OverrideImplementMethodsHandler handler) { private void doMultiOverrideImplement(OverrideImplementMethodsHandler handler) {
@@ -183,7 +183,7 @@ public abstract class AbstractOverrideImplementTest extends JetLightCodeInsightF
} }
}); });
performGenerateCommand(classOrObject, OverrideImplementMethodsHandler.membersFromDescriptors(jetFile, descriptorsList)); performGenerateCommand(classOrObject, OverrideImplementMethodsHandler.Companion.membersFromDescriptors(jetFile, descriptorsList));
} }
private void generateImplementation(@NotNull final PsiMethod method) { private void generateImplementation(@NotNull final PsiMethod method) {
@@ -210,7 +210,7 @@ public abstract class AbstractOverrideImplementTest extends JetLightCodeInsightF
new WriteCommandAction(myFixture.getProject(), myFixture.getFile()) { new WriteCommandAction(myFixture.getProject(), myFixture.getFile()) {
@Override @Override
protected void run(@NotNull Result result) throws Throwable { protected void run(@NotNull Result result) throws Throwable {
OverrideImplementMethodsHandler.generateMethods(myFixture.getEditor(), classOrObject, descriptorsToGenerate); OverrideImplementMethodsHandler.Companion.generateMethods(myFixture.getEditor(), classOrObject, descriptorsToGenerate);
} }
}.performCommand(); }.performCommand();
} }