diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java index 29987c4d7c5..10f6593042a 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java @@ -164,7 +164,7 @@ public class JetChangeInfo implements ChangeInfo { private Map initOldNameToParameterIndex() { Map map = new HashMap(); - FunctionDescriptor descriptor = oldDescriptor.getDescriptor(); + FunctionDescriptor descriptor = oldDescriptor.getBaseDescriptor(); if (descriptor != null) { List parameters = descriptor.getValueParameters(); @@ -259,7 +259,7 @@ public class JetChangeInfo implements ChangeInfo { @Nullable public FunctionDescriptor getOldDescriptor() { - return oldDescriptor.getDescriptor(); + return oldDescriptor.getBaseDescriptor(); } public JetMethodDescriptor getFunctionDescriptor() { @@ -267,7 +267,7 @@ public class JetChangeInfo implements ChangeInfo { } public boolean isConstructor() { - return oldDescriptor.isConstructor(); + return ChangeSignaturePackage.getIsConstructor(oldDescriptor); } public void setNewReturnTypeText(String newReturnTypeText) { @@ -276,7 +276,7 @@ public class JetChangeInfo implements ChangeInfo { @Override public boolean isReturnTypeChanged() { - return !newReturnTypeText.equals(oldDescriptor.getReturnTypeText()); + return !newReturnTypeText.equals(ChangeSignaturePackage.renderOriginalReturnType(oldDescriptor)); } @Nullable @@ -376,7 +376,7 @@ public class JetChangeInfo implements ChangeInfo { //noinspection ConstantConditions final List originalParameterDescriptors = - originalChangeSignatureDescriptor.getDescriptor().getValueParameters(); + originalChangeSignatureDescriptor.getBaseDescriptor().getValueParameters(); List newParameters = KotlinPackage.map( diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt index 3202d28d129..d3918157347 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt @@ -118,7 +118,7 @@ public class JetChangeSignature(val project: Project, return } - val affectedFunctions = dialog.getMethodDescriptor().getAffectedFunctions().map { it.getElement() }.filterNotNull() + val affectedFunctions = dialog.getMethodDescriptor().affectedFunctions.map { it.getElement() }.filterNotNull() if (affectedFunctions.any { !checkModifiable(it) }) { return diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt index 479f2b16355..f6775f69570 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt @@ -14,258 +14,134 @@ * limitations under the License. */ -package org.jetbrains.jet.plugin.refactoring.changeSignature; +package org.jetbrains.jet.plugin.refactoring.changeSignature -import com.google.common.collect.Sets; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.search.searches.OverridingMethodsSearch; -import com.intellij.refactoring.changeSignature.MethodDescriptor; -import com.intellij.refactoring.changeSignature.OverriderUsageInfo; -import com.intellij.usageView.UsageInfo; -import com.intellij.util.Function; -import com.intellij.util.containers.ContainerUtil; -import kotlin.Function1; -import kotlin.KotlinPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.KotlinLightMethod; -import org.jetbrains.jet.asJava.LightClassUtil; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; -import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil; -import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage; -import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers; +import com.intellij.psi.PsiElement +import com.intellij.psi.search.searches.OverridingMethodsSearch +import com.intellij.refactoring.changeSignature.MethodDescriptor +import com.intellij.refactoring.changeSignature.OverriderUsageInfo +import com.intellij.usageView.UsageInfo +import org.jetbrains.jet.asJava.KotlinLightMethod +import org.jetbrains.jet.asJava.LightClassUtil +import org.jetbrains.jet.lang.descriptors.* +import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor +import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.plugin.caches.resolve.* +import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil +import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage -import java.util.*; +import java.util.* +import kotlin.properties.Delegates -public final class JetChangeSignatureData implements JetMethodDescriptor { - @NotNull - private final FunctionDescriptor baseDescriptor; - @NotNull - private final PsiElement baseDeclaration; - @NotNull - private final List parameters; - @NotNull - private final Collection descriptorsForSignatureChange; - private JetFunctionDefinitionUsage originalPrimaryFunction; - private Collection> primaryFunctions = null; - private Collection affectedFunctions = null; +public class JetChangeSignatureData( + override val baseDescriptor: FunctionDescriptor, + override val baseDeclaration: PsiElement, + private val descriptorsForSignatureChange: Collection +) : JetMethodDescriptor { + private val parameters: MutableList - public JetChangeSignatureData( - @NotNull FunctionDescriptor baseDescriptor, - @NotNull PsiElement baseDeclaration, - @NotNull Collection descriptorsForSignatureChange - ) { - this.baseDescriptor = baseDescriptor; - this.baseDeclaration = baseDeclaration; - this.descriptorsForSignatureChange = descriptorsForSignatureChange; - final List valueParameters = this.baseDeclaration instanceof JetFunction - ? ((JetFunction) this.baseDeclaration).getValueParameters() - : this.baseDeclaration instanceof JetClass - ? ((JetClass) this.baseDeclaration).getPrimaryConstructorParameters() - : null; - this.parameters = new ArrayList( - ContainerUtil.map(this.baseDescriptor.getValueParameters(), new Function() { - @Override - public JetParameterInfo fun(ValueParameterDescriptor param) { - JetParameter parameter = valueParameters != null ? valueParameters.get(param.getIndex()) : null; - JetParameterInfo parameterInfo = new JetParameterInfo( - param.getIndex(), - param.getName().asString(), - param.getType(), - parameter != null ? parameter.getDefaultValue() : null, - parameter != null ? parameter.getValOrVarNode() : null - ); - parameterInfo.setModifierList(parameter != null ? parameter.getModifierList() : null); - return parameterInfo; - } - })); - } - - @Override - @NotNull - public List getParameters() { - return parameters; - } - - public void addParameter(JetParameterInfo parameter) { - parameters.add(parameter); - } - - public void removeParameter(int index) { - parameters.remove(index); - } - - public void clearParameters() { - parameters.clear(); - } - - @NotNull - @Override - public JetFunctionDefinitionUsage getOriginalPrimaryFunction() { - if (originalPrimaryFunction == null) { - originalPrimaryFunction = KotlinPackage.first( - getPrimaryFunctions(), - new Function1, Boolean>() { - @Override - public Boolean invoke(JetFunctionDefinitionUsage usage) { - return usage.getDeclaration() == baseDeclaration; - } - } - ); + ;{ + val valueParameters = when { + baseDeclaration is JetFunction -> baseDeclaration.getValueParameters() + baseDeclaration is JetClass -> baseDeclaration.getPrimaryConstructorParameters() + else -> null + } + parameters = baseDescriptor.getValueParameters().mapTo(ArrayList()) { parameterDescriptor -> + val jetParameter = valueParameters?.get(parameterDescriptor.getIndex()) + val parameterInfo = JetParameterInfo( + parameterDescriptor.getIndex(), + parameterDescriptor.getName().asString(), + parameterDescriptor.getType(), + jetParameter?.getDefaultValue(), + jetParameter?.getValOrVarNode() + ) + parameterInfo.setModifierList(jetParameter?.getModifierList()) + parameterInfo } - return originalPrimaryFunction; } - @Override - @NotNull - public Collection> getPrimaryFunctions() { - if (primaryFunctions == null) { - primaryFunctions = KotlinPackage.map( - descriptorsForSignatureChange, - new Function1>() { - @Override - public JetFunctionDefinitionUsage invoke(FunctionDescriptor descriptor) { - PsiElement declaration = DescriptorToDeclarationUtil.INSTANCE$.getDeclaration(baseDeclaration.getProject(), - descriptor); - assert declaration != null : "No declaration found for " + descriptor; - return new JetFunctionDefinitionUsage(declaration, descriptor, null, null); - } - } - ); + override val primaryFunctions: Collection> by Delegates.lazy { + descriptorsForSignatureChange.map { + val declaration = DescriptorToDeclarationUtil.getDeclaration(baseDeclaration.getProject(), it) + assert(declaration != null) { "No declaration found for " + baseDescriptor } + JetFunctionDefinitionUsage(declaration, it, null, null) } - - return primaryFunctions; } - @Override - @NotNull - public Collection getAffectedFunctions() { - if (affectedFunctions == null) { - affectedFunctions = KotlinPackage.flatMapTo( - getPrimaryFunctions(), - new HashSet(), - new Function1, Iterable>() { - @Override - public Iterable invoke(final JetFunctionDefinitionUsage primaryFunction) { - Set result = Sets.newHashSet(); - result.add(primaryFunction); - - PsiElement primaryDeclaration = primaryFunction.getDeclaration(); - if (!(primaryDeclaration instanceof JetNamedFunction)) return result; - - final PsiMethod baseLightMethod = LightClassUtil.getLightClassMethod((JetNamedFunction) primaryDeclaration); - // there are valid situations when light method is null: local functions and literals - if (baseLightMethod == null) return result; - - return KotlinPackage.filterNotNullTo( - KotlinPackage.map( - OverridingMethodsSearch.search(baseLightMethod).findAll(), - new Function1() { - @Override - public UsageInfo invoke(PsiMethod method) { - if (method instanceof KotlinLightMethod) { - JetDeclaration declaration = ((KotlinLightMethod) method).getOrigin(); - if (declaration == null) return null; - - FunctionDescriptor currentDescriptor = - (FunctionDescriptor) ResolvePackage.resolveToDescriptor(declaration); - - return new JetFunctionDefinitionUsage(declaration, - currentDescriptor, - primaryFunction, - null); - } - - return new OverriderUsageInfo(method, baseLightMethod, true, true, true); - } - } - ), - result - ); - } - } - ); - } - return affectedFunctions; + override val originalPrimaryFunction: JetFunctionDefinitionUsage by Delegates.lazy { + primaryFunctions.first { it.getDeclaration() == baseDeclaration } } - @Override - public String getName() { - if (baseDescriptor instanceof ConstructorDescriptor) { - return baseDescriptor.getContainingDeclaration().getName().asString(); + override val affectedFunctions: Collection by Delegates.lazy { + primaryFunctions + primaryFunctions.flatMapTo(HashSet()) { primaryFunction -> + val primaryDeclaration = primaryFunction.getDeclaration() as? JetNamedFunction + val lightMethod = primaryDeclaration?.let { LightClassUtil.getLightClassMethod(it) } + val overrides = lightMethod?.let { OverridingMethodsSearch.search(it).findAll() } ?: Collections.emptyList() + overrides.map { method -> + if (method is KotlinLightMethod) { + val overridingDeclaration = method.origin + val overridingDescriptor = overridingDeclaration?.resolveToDescriptor() as FunctionDescriptor + JetFunctionDefinitionUsage(overridingDeclaration, overridingDescriptor, primaryFunction, null) + } + else OverriderUsageInfo(method, lightMethod, true, true, true) + }.filterNotNullTo(HashSet()) } - else if (baseDescriptor instanceof AnonymousFunctionDescriptor) { - return ""; + } + + override fun getParameters(): List { + return parameters + } + + public fun addParameter(parameter: JetParameterInfo) { + parameters.add(parameter) + } + + public fun removeParameter(index: Int) { + parameters.remove(index) + } + + public fun clearParameters() { + parameters.clear() + } + + override fun getName(): String { + if (baseDescriptor is ConstructorDescriptor) { + return baseDescriptor.getContainingDeclaration().getName().asString() + } + else if (baseDescriptor is AnonymousFunctionDescriptor) { + return "" } else { - return baseDescriptor.getName().asString(); + return baseDescriptor.getName().asString() } } - @Override - public int getParametersCount() { - return baseDescriptor.getValueParameters().size(); + override fun getParametersCount(): Int { + return baseDescriptor.getValueParameters().size() } - @Override - public Visibility getVisibility() { - return baseDescriptor.getVisibility(); + override fun getVisibility(): Visibility { + return baseDescriptor.getVisibility() } - @Override - public PsiElement getMethod() { - return baseDeclaration; + override fun getMethod(): PsiElement { + return baseDeclaration } - @Override - public boolean canChangeVisibility() { - DeclarationDescriptor parent = baseDescriptor.getContainingDeclaration(); - return !(baseDescriptor instanceof AnonymousFunctionDescriptor || - parent instanceof ClassDescriptor && ((ClassDescriptor) parent).getKind() == ClassKind.TRAIT); + override fun canChangeVisibility(): Boolean { + val parent = baseDescriptor.getContainingDeclaration() + return !(baseDescriptor is AnonymousFunctionDescriptor || parent is ClassDescriptor && parent.getKind() == ClassKind.TRAIT) } - @Override - public boolean canChangeParameters() { - return true; + override fun canChangeParameters(): Boolean { + return true } - @Override - public boolean canChangeName() { - return !(baseDescriptor instanceof ConstructorDescriptor || - baseDescriptor instanceof AnonymousFunctionDescriptor); + override fun canChangeName(): Boolean { + return !(baseDescriptor is ConstructorDescriptor || baseDescriptor is AnonymousFunctionDescriptor) } - @Override - public MethodDescriptor.ReadWriteOption canChangeReturnType() { - return baseDescriptor instanceof ConstructorDescriptor ? ReadWriteOption.None : ReadWriteOption.ReadWrite; - } - - @Override - public boolean isConstructor() { - return baseDescriptor instanceof ConstructorDescriptor; - } - - @NotNull - @Override - public PsiElement getContext() { - return baseDeclaration; - } - - @Nullable - @Override - public FunctionDescriptor getDescriptor() { - return baseDescriptor; - } - - @Override - @Nullable - public String getReturnTypeText() { - JetType returnType = baseDescriptor.getReturnType(); - return returnType != null ? IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(returnType) : null; + override fun canChangeReturnType(): MethodDescriptor.ReadWriteOption { + return if (baseDescriptor is ConstructorDescriptor) MethodDescriptor.ReadWriteOption.None else MethodDescriptor.ReadWriteOption.ReadWrite } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java index 5d298941859..e65bfc064df 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java @@ -91,7 +91,7 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override protected JetFunctionParameterTableModel createParametersInfoModel(JetMethodDescriptor descriptor) { - if (descriptor.isConstructor()) + if (ChangeSignaturePackage.getIsConstructor(descriptor)) return new JetConstructorParameterTableModel(myDefaultValueContext); else return new JetFunctionParameterTableModel(myDefaultValueContext); @@ -99,7 +99,9 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override protected PsiCodeFragment createReturnTypeCodeFragment() { - return JetPsiFactory(myProject).createTypeCodeFragment(myMethod.getReturnTypeText(), myMethod.getContext()); + return JetPsiFactory(myProject).createTypeCodeFragment( + ChangeSignaturePackage.renderOriginalReturnType(myMethod), myMethod.getBaseDeclaration() + ); } @Nullable @@ -116,7 +118,7 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< JPanel panel = new JPanel(new BorderLayout()); String valOrVar = ""; - if (myMethod.isConstructor()) { + if (ChangeSignaturePackage.getIsConstructor(myMethod)) { switch (item.parameter.getValOrVar()) { case None: valOrVar = " "; @@ -313,7 +315,7 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< new int[] { 4, getParamNamesMaxLength(), getTypesMaxLength() }; int columnIndex = 0; - for (int i = myMethod.isConstructor() ? 0 : 1; i < columnLetters.length; i ++) { + for (int i = ChangeSignaturePackage.getIsConstructor(myMethod) ? 0 : 1; i < columnLetters.length; i ++) { int width = getColumnWidth(columnLetters[i]); if (x <= width) @@ -329,7 +331,9 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< @Override public JComponent getPreferredFocusedComponent() { MouseEvent me = getMouseEvent(); - int index = me != null ? getEditorIndex((int) me.getPoint().getX()) : myMethod.isConstructor() ? 1 : 0; + int index = me != null + ? getEditorIndex((int) me.getPoint().getX()) + : ChangeSignaturePackage.getIsConstructor(myMethod) ? 1 : 0; JComponent component = components.get(index); return component instanceof EditorTextField ? ((EditorTextField) component).getFocusTarget() : component; } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetMethodDescriptor.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetMethodDescriptor.kt index 43f21834572..57196b9f847 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetMethodDescriptor.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetMethodDescriptor.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,37 +14,28 @@ * limitations under the License. */ -package org.jetbrains.jet.plugin.refactoring.changeSignature; +package org.jetbrains.jet.plugin.refactoring.changeSignature -import com.intellij.psi.PsiElement; -import com.intellij.refactoring.changeSignature.MethodDescriptor; -import com.intellij.usageView.UsageInfo; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.Visibility; -import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage; +import com.intellij.psi.PsiElement +import com.intellij.refactoring.changeSignature.MethodDescriptor +import com.intellij.usageView.UsageInfo +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.lang.descriptors.Visibility +import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor +import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers -import java.util.Collection; +public trait JetMethodDescriptor : MethodDescriptor { + val baseDeclaration: PsiElement + val baseDescriptor: FunctionDescriptor -public interface JetMethodDescriptor extends MethodDescriptor { - @NotNull - JetFunctionDefinitionUsage getOriginalPrimaryFunction(); - - @NotNull - Collection> getPrimaryFunctions(); - - @NotNull - Collection getAffectedFunctions(); - - boolean isConstructor(); - - @Nullable - String getReturnTypeText(); - - @NotNull - PsiElement getContext(); - - @Nullable - FunctionDescriptor getDescriptor(); + val originalPrimaryFunction: JetFunctionDefinitionUsage + val primaryFunctions: Collection> + val affectedFunctions: Collection } + +val JetMethodDescriptor.isConstructor: Boolean + get() = baseDescriptor is ConstructorDescriptor + +fun JetMethodDescriptor.renderOriginalReturnType(): String = + baseDescriptor.getReturnType()?.let { IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(it) } ?: "" \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt index 52650ae52b5..0de894f1b7b 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt @@ -35,7 +35,7 @@ public abstract class JavaMethodKotlinUsageWithDelegate( public class JavaMethodKotlinCallUsage( callElement: JetCallElement, javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate(callElement, javaMethodChangeInfo) { - override protected val delegateUsage = JetFunctionCallUsage(psiElement, javaMethodChangeInfo.getFunctionDescriptor().getOriginalPrimaryFunction()) + override protected val delegateUsage = JetFunctionCallUsage(psiElement, javaMethodChangeInfo.getFunctionDescriptor().originalPrimaryFunction) } public class JavaMethodKotlinDerivedDefinitionUsage( @@ -46,7 +46,7 @@ public class JavaMethodKotlinDerivedDefinitionUsage( override protected val delegateUsage = JetFunctionDefinitionUsage( psiElement, functionDescriptor, - javaMethodChangeInfo.getFunctionDescriptor().getOriginalPrimaryFunction(), + javaMethodChangeInfo.getFunctionDescriptor().originalPrimaryFunction, null ) } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt index 1a29e6f8d2e..de6b87afbaa 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt @@ -19,10 +19,8 @@ package org.jetbrains.jet.plugin.refactoring.changeSignature.usages import org.jetbrains.jet.lang.psi.JetEnumEntry import org.jetbrains.jet.plugin.refactoring.changeSignature.JetChangeInfo import org.jetbrains.jet.lang.psi.JetPsiFactory -import org.jetbrains.jet.lang.psi.psiUtil.getNonStrictParentOfType import org.jetbrains.jet.lang.psi.JetClass import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall -import org.jetbrains.jet.lang.psi.psiUtil.getParentOfType import org.jetbrains.jet.lang.psi.psiUtil.getStrictParentOfType public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsageInfo(enumEntry) { @@ -37,7 +35,7 @@ public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsa ) as JetDelegatorToSuperCall element.addBefore(psiFactory.createColon(), delegatorToSuperCall) - return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.getFunctionDescriptor().getOriginalPrimaryFunction()) + return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.getFunctionDescriptor().originalPrimaryFunction) .processUsage(changeInfo, delegatorToSuperCall) }