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

Diagnostic parameter types added; opportunity to import class of known type added

Browse Source
This commit is contained in:
svtk
2011-09-27 16:25:17 +04:00
parent 87b22e810f
commit fdac4c7ef4
39 changed files with 489 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java
+73
View File
@@ -0,0 +1,73 @@
package org.jetbrains.jet.plugin;
import com.google.common.collect.Lists;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.DeferredType;
import org.jetbrains.jet.lang.types.JetStandardLibrary;
import org.jetbrains.jet.lang.types.JetType;
import java.util.LinkedList;
/**
* @author svtk
*/
public class JetPluginUtil {
@NotNull
public static String computeTypeFullName(JetType type) {
LinkedList<String> fullName = computeTypeFullNameList(type);
String last = fullName.getLast();
StringBuilder sb = new StringBuilder();
for (String s : fullName) {
sb.append(s);
if (s != last) {
sb.append('.');
}
}
return sb.toString();
}
@NotNull
private static LinkedList<String> computeTypeFullNameList(JetType type) {
if (type instanceof DeferredType) {
type = ((DeferredType)type).getActualType();
}
DeclarationDescriptor declarationDescriptor = type.getConstructor().getDeclarationDescriptor();
LinkedList<String> fullName = Lists.newLinkedList();
while (declarationDescriptor != null) {
fullName.addFirst(declarationDescriptor.getName());
declarationDescriptor = declarationDescriptor.getContainingDeclaration();
}
assert fullName.size() > 0;
if (JavaDescriptorResolver.JAVA_ROOT.equals(fullName.getFirst())) {
fullName.removeFirst();
}
return fullName;
}
public static boolean checkTypeIsStandard(JetType type, Project project) {
LinkedList<String> fullName = computeTypeFullNameList(type);
if (fullName.size() == 3 && fullName.getFirst().equals("java") && fullName.get(1).equals("lang")) {
return true;
}
JetStandardLibrary standardLibrary = JetStandardLibrary.getJetStandardLibrary(project);
JetScope libraryScope = standardLibrary.getLibraryScope();
DeclarationDescriptor declaration = type.getMemberScope().getContainingDeclaration();
if (declaration instanceof JavaClassDescriptor) {
return false;
}
while (!(declaration instanceof NamespaceDescriptor)) {
declaration = declaration.getContainingDeclaration();
assert declaration != null;
}
return libraryScope == ((NamespaceDescriptor) declaration).getMemberScope();
}
}
idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java
+3 -3
View File
@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.plugin.AnalyzerFacade;
import org.jetbrains.jet.plugin.JetHighlighter;
import org.jetbrains.jet.plugin.quickfix.IntentionActionFactory;
import org.jetbrains.jet.plugin.quickfix.JetIntentionActionFactory;
import org.jetbrains.jet.plugin.quickfix.QuickFixes;
import java.util.Collection;
@@ -90,8 +90,8 @@ public class JetPsiChecker implements Annotator {
DiagnosticWithPsiElement diagnosticWithPsiElement = (DiagnosticWithPsiElement) diagnostic;
if (diagnostic.getFactory() instanceof PsiElementOnlyDiagnosticFactory) {
PsiElementOnlyDiagnosticFactory factory = (PsiElementOnlyDiagnosticFactory) diagnostic.getFactory();
Collection<IntentionActionFactory> intentionActionFactories = QuickFixes.get(factory);
for (IntentionActionFactory intentionActionFactory : intentionActionFactories) {
Collection<JetIntentionActionFactory> intentionActionFactories = QuickFixes.get(factory);
for (JetIntentionActionFactory intentionActionFactory : intentionActionFactories) {
IntentionAction action = null;
if (intentionActionFactory != null) {
action = intentionActionFactory.createAction(diagnosticWithPsiElement);
idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java
+4 -5
View File
@@ -8,12 +8,11 @@ import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class AddFunctionBodyFix extends IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> {
public class AddFunctionBodyFix extends JetIntentionAction<JetFunctionOrPropertyAccessor> {
public AddFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
super(element);
}
@@ -49,10 +48,10 @@ public class AddFunctionBodyFix extends IntentionActionForPsiElement<JetFunction
element.replace(newElement);
}
public static IntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetFunctionOrPropertyAccessor>() {
public static JetIntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new JetIntentionActionFactory<JetFunctionOrPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
return new AddFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
}
idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java
+4 -4
View File
@@ -97,17 +97,17 @@ public class AddModifierFix extends ModifierFix {
return true;
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier, final JetToken[] modifiersThatCanBeReplaced, final JetToken[] conflictedModifiers) {
return new IntentionActionFactory<JetModifierListOwner>() {
public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier, final JetToken[] modifiersThatCanBeReplaced, final JetToken[] conflictedModifiers) {
return new JetIntentionActionFactory<JetModifierListOwner>() {
@Override
public IntentionActionForPsiElement<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetModifierListOwner;
return new AddModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier, modifiersThatCanBeReplaced, conflictedModifiers);
}
};
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
return createFactory(modifier, new JetToken[0], new JetToken[0]);
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java
+10 -8
View File
@@ -2,11 +2,13 @@ package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetParameter;
import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
@@ -17,7 +19,7 @@ import org.jetbrains.jet.lang.types.JetType;
/**
* @author svtk
*/
public class ChangeAccessorTypeFix extends IntentionActionForPsiElement<JetPropertyAccessor> {
public class ChangeAccessorTypeFix extends JetIntentionAction<JetPropertyAccessor> {
private final JetType type;
public ChangeAccessorTypeFix(@NotNull JetPropertyAccessor element, JetType type) {
@@ -58,14 +60,14 @@ public class ChangeAccessorTypeFix extends IntentionActionForPsiElement<JetPrope
}
}
public static IntentionActionFactory<JetPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetPropertyAccessor>() {
public static JetIntentionActionFactory<JetPropertyAccessor> createFactory() {
return new JetIntentionActionFactory<JetPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
public JetIntentionAction<JetPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetPropertyAccessor;
assert ((DiagnosticWithAdditionalInfo) diagnostic).getInfo() instanceof JetType;
return new ChangeAccessorTypeFix((JetPropertyAccessor) diagnostic.getPsiElement(), (JetType) ((DiagnosticWithAdditionalInfo) diagnostic).getInfo());
DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.TYPE);
JetType type = diagnosticWithParameters.getParameter(DiagnosticParameters.TYPE);
return new ChangeAccessorTypeFix((JetPropertyAccessor) diagnostic.getPsiElement(), type);
}
};
}
idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableMutabilityFix.java
+4 -4
View File
@@ -15,7 +15,7 @@ import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class ChangeVariableMutabilityFix extends IntentionActionForPsiElement<JetProperty> {
public class ChangeVariableMutabilityFix extends JetIntentionAction<JetProperty> {
public ChangeVariableMutabilityFix(@NotNull JetProperty element) {
super(element);
}
@@ -52,10 +52,10 @@ public class ChangeVariableMutabilityFix extends IntentionActionForPsiElement<Je
element.replace(newElement);
}
public static IntentionActionFactory<JetProperty> createFactory() {
return new IntentionActionFactory<JetProperty>() {
public static JetIntentionActionFactory<JetProperty> createFactory() {
return new JetIntentionActionFactory<JetProperty>() {
@Override
public IntentionActionForPsiElement<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetProperty;
return new ChangeVariableMutabilityFix((JetProperty) diagnostic.getPsiElement());
}
idea/src/org/jetbrains/jet/plugin/quickfix/ImportClassHelper.java
+57
View File
@@ -0,0 +1,57 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.plugin.JetPluginUtil;
import java.util.List;
/**
* @author svtk
*/
public class ImportClassHelper {
public static void perform(@NotNull JetType type, @NotNull PsiElement element, @NotNull PsiElement newElement) {
PsiElement parent = element;
while (!(parent instanceof JetNamespace)) {
parent = parent.getParent();
assert parent != null;
}
JetNamespace namespace = (JetNamespace) parent;
List<JetImportDirective> importDirectives = namespace.getImportDirectives();
if (JetPluginUtil.checkTypeIsStandard(type, element.getProject())) {
element.replace(newElement);
return;
}
String typeFullName = JetPluginUtil.computeTypeFullName(type);
JetImportDirective newDirective = JetPsiFactory.createImportDirective(element.getProject(), typeFullName);
if (!importDirectives.isEmpty()) {
boolean isPresent = false;
for (JetImportDirective directive : importDirectives) {
if (directive.getText().endsWith(typeFullName) ||
directive.getText().endsWith(typeFullName + ";")) {
isPresent = true;
}
}
if (!isPresent) {
JetImportDirective lastDirective = importDirectives.get(importDirectives.size() - 1);
lastDirective.getParent().addAfter(newDirective, lastDirective);
lastDirective.getParent().addAfter(JetPsiFactory.createWhiteSpace(element.getProject(), "\n"), lastDirective);
}
}
else {
List<JetDeclaration> declarations = namespace.getDeclarations();
assert !declarations.isEmpty();
JetDeclaration firstDeclaration = declarations.iterator().next();
firstDeclaration.getParent().addBefore(newDirective, firstDeclaration);
firstDeclaration.getParent().addBefore(JetPsiFactory.createWhiteSpace(element.getProject(), "\n\n"), firstDeclaration);
}
element.replace(newElement);
parent.replace(namespace);
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/IntentionActionForPsiElement.java
-29
View File
@@ -1,29 +0,0 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.intention.IntentionAction;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
/**
* @author svtk
*/
public abstract class IntentionActionForPsiElement<T extends PsiElement> implements IntentionAction {
protected @NotNull T element;
public IntentionActionForPsiElement(@NotNull T element) {
this.element = element;
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
}
@Override
public boolean startInWriteAction() {
return true;
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java
+46
View File
@@ -0,0 +1,46 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.codeInsight.intention.IntentionAction;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameter;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
import java.util.Arrays;
/**
* @author svtk
*/
public abstract class JetIntentionAction<T extends PsiElement> implements IntentionAction {
protected @NotNull T element;
public JetIntentionAction(@NotNull T element) {
this.element = element;
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return element.isValid();
}
@Override
public boolean startInWriteAction() {
return true;
}
public static DiagnosticWithParameters<PsiElement> assertAndCastToDiagnosticWithParameters(Diagnostic diagnostic, DiagnosticParameter... parameters) {
assert diagnostic instanceof DiagnosticWithParameters :
"For this type of quick fix diagnostic with additional " +
(parameters.length == 1 ? "parameter '" + parameters[0] + "'" : "parameters " + Arrays.asList(parameters)) + " is expected";
for (DiagnosticParameter parameter : parameters) {
assert ((DiagnosticWithParameters) diagnostic).hasParameter(parameter) :
"For this type of quick fix diagnostic with additional parameter '" + parameter + "' is expected";
}
return (DiagnosticWithParameters<PsiElement>) diagnostic;
}
}
idea/src/org/jetbrains/jet/plugin/quickfix/IntentionActionFactory.java → idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java
+2 -2
View File
@@ -6,8 +6,8 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
/**
* @author svtk
*/
public interface IntentionActionFactory<T extends PsiElement> {
public interface JetIntentionActionFactory<T extends PsiElement> {
IntentionActionForPsiElement<T> createAction(DiagnosticWithPsiElement diagnostic);
JetIntentionAction<T> createAction(DiagnosticWithPsiElement diagnostic);
}
idea/src/org/jetbrains/jet/plugin/quickfix/ModifierFix.java
+1 -1
View File
@@ -9,7 +9,7 @@ import org.jetbrains.jet.lexer.JetKeywordToken;
/**
* @author svtk
*/
public abstract class ModifierFix extends IntentionActionForPsiElement<JetModifierListOwner> {
public abstract class ModifierFix extends JetIntentionAction<JetModifierListOwner> {
protected final JetKeywordToken modifier;
protected ModifierFix(@NotNull JetModifierListOwner element, JetKeywordToken modifier) {
idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java
+8 -14
View File
@@ -1,7 +1,8 @@
package org.jetbrains.jet.plugin.quickfix;
import com.intellij.psi.PsiElement;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameter;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElementImpl;
@@ -11,20 +12,13 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElementImpl;
public class QuickFixUtil {
private QuickFixUtil() {}
public static <T extends PsiElement> IntentionActionFactory<T> createFactoryRedirectingAdditionalInfoToAnotherFactory(final IntentionActionFactory<T> factory) {
return new IntentionActionFactory<T>() {
public static <T extends PsiElement> JetIntentionActionFactory<T> createFactoryRedirectingAdditionalInfoToAnotherFactory(final JetIntentionActionFactory<T> factory, final DiagnosticParameter<T> parameter) {
return new JetIntentionActionFactory<T>() {
@Override
public IntentionActionForPsiElement<T> createAction(DiagnosticWithPsiElement diagnostic) {
//no type check; should be followed manually
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
Object info = ((DiagnosticWithAdditionalInfo) diagnostic).getInfo();
T element = null;
try {
element = (T) info;
}
catch (ClassCastException ex) {
assert false : ex;
}
public JetIntentionAction<T> createAction(DiagnosticWithPsiElement diagnostic) {
DiagnosticWithParameters<PsiElement> diagnosticWithParameters = JetIntentionAction.assertAndCastToDiagnosticWithParameters(diagnostic, parameter);
T element = diagnosticWithParameters.getParameter(parameter);
return factory.createAction(new DiagnosticWithPsiElementImpl<T>(diagnostic.getFactory(), diagnostic.getSeverity(), diagnostic.getMessage(), element));
}
};
idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java
+13 -10
View File
@@ -3,6 +3,7 @@ package org.jetbrains.jet.plugin.quickfix;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import com.intellij.psi.PsiElement;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.diagnostics.PsiElementOnlyDiagnosticFactory;
import org.jetbrains.jet.lang.psi.JetFunctionOrPropertyAccessor;
@@ -18,26 +19,26 @@ import java.util.Collection;
* @author svtk
*/
public class QuickFixes {
private static final Multimap<PsiElementOnlyDiagnosticFactory, IntentionActionFactory> actionMap = HashMultimap.create();
private static final Multimap<PsiElementOnlyDiagnosticFactory, JetIntentionActionFactory> actionMap = HashMultimap.create();
public static Collection<IntentionActionFactory> get(PsiElementOnlyDiagnosticFactory diagnosticFactory) {
public static Collection<JetIntentionActionFactory> get(PsiElementOnlyDiagnosticFactory diagnosticFactory) {
return actionMap.get(diagnosticFactory);
}
private QuickFixes() {}
private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<? extends T> diagnosticFactory, IntentionActionFactory<T> actionFactory) {
private static <T extends PsiElement> void add(PsiElementOnlyDiagnosticFactory<? extends T> diagnosticFactory, JetIntentionActionFactory<T> actionFactory) {
actionMap.put(diagnosticFactory, actionFactory);
}
static {
IntentionActionFactory<JetModifierListOwner> removeAbstractModifierFactory = RemoveModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD);
IntentionActionFactory<JetModifierListOwner> addAbstractModifierFactory = AddModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD, new JetToken[]{JetTokens.OPEN_KEYWORD}, new JetToken[] {JetTokens.FINAL_KEYWORD});
JetIntentionActionFactory<JetModifierListOwner> removeAbstractModifierFactory = RemoveModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD);
JetIntentionActionFactory<JetModifierListOwner> addAbstractModifierFactory = AddModifierFix.createFactory(JetTokens.ABSTRACT_KEYWORD, new JetToken[]{JetTokens.OPEN_KEYWORD}, new JetToken[] {JetTokens.FINAL_KEYWORD});
add(Errors.ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_NOT_IN_CLASS, removeAbstractModifierFactory);
IntentionActionFactory<JetProperty> removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory();
JetIntentionActionFactory<JetProperty> removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory();
add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_INITIALIZER, removePartsFromPropertyFactory);
@@ -47,21 +48,23 @@ public class QuickFixes {
add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_WITH_SETTER, removePartsFromPropertyFactory);
add(Errors.PROPERTY_INITIALIZER_IN_TRAIT, removePartsFromPropertyFactory);
add(Errors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory);
add(Errors.REDUNDANT_ABSTRACT, removeAbstractModifierFactory);
IntentionActionFactory<JetModifierListOwner> addAbstractToClassFactory = QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory);
JetIntentionActionFactory<JetModifierListOwner> addAbstractToClassFactory = QuickFixUtil.createFactoryRedirectingAdditionalInfoToAnotherFactory(addAbstractModifierFactory, DiagnosticParameters.CLASS);
add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
IntentionActionFactory<JetFunctionOrPropertyAccessor> removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory();
JetIntentionActionFactory<JetFunctionOrPropertyAccessor> removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory();
add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory);
add(Errors.ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory);
add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeAbstractModifierFactory);
add(Errors.ABSTRACT_FUNCTION_WITH_BODY, removeFunctionBodyFactory);
IntentionActionFactory<JetFunctionOrPropertyAccessor> addFunctionBodyFactory = AddFunctionBodyFix.createFactory();
JetIntentionActionFactory<JetFunctionOrPropertyAccessor> addFunctionBodyFactory = AddFunctionBodyFix.createFactory();
add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addAbstractModifierFactory);
add(Errors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addFunctionBodyFactory);
@@ -77,7 +80,7 @@ public class QuickFixes {
add(Errors.USELESS_CAST_STATIC_ASSERT_IS_FINE, ReplaceOperationInBinaryExpressionFix.createChangeCastToStaticAssertFactory());
add(Errors.USELESS_CAST, RemoveRightPartOfBinaryExpressionFix.createRemoveCastFactory());
IntentionActionFactory<JetPropertyAccessor> changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory();
JetIntentionActionFactory<JetPropertyAccessor> changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory();
add(Errors.WRONG_SETTER_PARAMETER_TYPE, changeAccessorTypeFactory);
add(Errors.WRONG_GETTER_RETURN_TYPE, changeAccessorTypeFactory);
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java
+4 -5
View File
@@ -9,12 +9,11 @@ import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author svtk
*/
public class RemoveFunctionBodyFix extends IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> {
public class RemoveFunctionBodyFix extends JetIntentionAction<JetFunctionOrPropertyAccessor> {
public RemoveFunctionBodyFix(@NotNull JetFunctionOrPropertyAccessor element) {
super(element);
@@ -52,10 +51,10 @@ public class RemoveFunctionBodyFix extends IntentionActionForPsiElement<JetFunct
element.replace(newElement);
}
public static IntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new IntentionActionFactory<JetFunctionOrPropertyAccessor>() {
public static JetIntentionActionFactory<JetFunctionOrPropertyAccessor> createFactory() {
return new JetIntentionActionFactory<JetFunctionOrPropertyAccessor>() {
@Override
public IntentionActionForPsiElement<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetFunctionOrPropertyAccessor> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetFunctionOrPropertyAccessor;
return new RemoveFunctionBodyFix((JetFunctionOrPropertyAccessor) diagnostic.getPsiElement());
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java
+3 -3
View File
@@ -86,10 +86,10 @@ public class RemoveModifierFix extends ModifierFix {
return false;
}
public static IntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
return new IntentionActionFactory<JetModifierListOwner>() {
public static JetIntentionActionFactory<JetModifierListOwner> createFactory(final JetKeywordToken modifier) {
return new JetIntentionActionFactory<JetModifierListOwner>() {
@Override
public IntentionActionForPsiElement<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetModifierListOwner> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetModifierListOwner;
return new RemoveModifierFix((JetModifierListOwner) diagnostic.getPsiElement(), modifier);
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java
+23 -12
View File
@@ -6,21 +6,28 @@ import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.types.DeferredType;
import org.jetbrains.jet.lang.types.JetType;
/**
* @author svtk
*/
public class RemovePartsFromPropertyFix extends IntentionActionForPsiElement<JetProperty> {
public class RemovePartsFromPropertyFix extends JetIntentionAction<JetProperty> {
private final JetType type;
private final String partsToRemove;
private RemovePartsFromPropertyFix(@NotNull JetProperty element, JetType type) {
super(element);
this.type = type;
if (type instanceof DeferredType) {
this.type = ((DeferredType) type).getActualType();
}
else {
this.type = type;
}
partsToRemove = partsToRemove(element.getGetter() != null && element.getGetter().getBodyExpression() != null,
element.getSetter() != null && element.getSetter().getBodyExpression() != null,
element.getInitializer() != null);
@@ -78,6 +85,7 @@ public class RemovePartsFromPropertyFix extends IntentionActionForPsiElement<Jet
newElement.deleteChildInternal(setter.getNode());
}
JetExpression initializer = newElement.getInitializer();
boolean needImport = false;
if (initializer != null) {
PsiElement nameIdentifier = newElement.getNameIdentifier();
assert nameIdentifier != null;
@@ -87,9 +95,14 @@ public class RemovePartsFromPropertyFix extends IntentionActionForPsiElement<Jet
if (newElement.getPropertyTypeRef() == null) {
newElement = addPropertyType(project, newElement, type);
needImport = true;
}
}
element.replace(newElement);
if (needImport) {
ImportClassHelper.perform(type, element, newElement);
} else {
element.replace(newElement);
}
}
public static JetProperty addPropertyType(Project project, JetProperty property, JetType type) {
@@ -105,16 +118,14 @@ public class RemovePartsFromPropertyFix extends IntentionActionForPsiElement<Jet
return newProperty;
}
public static IntentionActionFactory<JetProperty> createFactory() {
return new IntentionActionFactory<JetProperty>() {
public static JetIntentionActionFactory<JetProperty> createFactory() {
return new JetIntentionActionFactory<JetProperty>() {
@Override
public IntentionActionForPsiElement<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetProperty> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetProperty;
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
Object info = ((DiagnosticWithAdditionalInfo) diagnostic).getInfo();
assert info instanceof JetType;
return new RemovePartsFromPropertyFix((JetProperty) diagnostic.getPsiElement(), (JetType) info);
DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.TYPE);
JetType type = diagnosticWithParameters.getParameter(DiagnosticParameters.TYPE);
return new RemovePartsFromPropertyFix((JetProperty) diagnostic.getPsiElement(), type);
}
};
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRedundantModifierFix.java
+10 -9
View File
@@ -2,10 +2,12 @@ package org.jetbrains.jet.plugin.quickfix;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithAdditionalInfo;
import org.jetbrains.jet.lang.diagnostics.DiagnosticParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters;
import org.jetbrains.jet.lang.diagnostics.DiagnosticWithPsiElement;
import org.jetbrains.jet.lang.psi.JetModifierList;
import org.jetbrains.jet.lexer.JetKeywordToken;
@@ -13,7 +15,7 @@ import org.jetbrains.jet.lexer.JetKeywordToken;
/**
* @author svtk
*/
public class RemoveRedundantModifierFix extends IntentionActionForPsiElement<JetModifierList> {
public class RemoveRedundantModifierFix extends JetIntentionAction<JetModifierList> {
private JetKeywordToken redundantModifier;
public RemoveRedundantModifierFix(@NotNull JetModifierList element, @NotNull JetKeywordToken redundantModifier) {
super(element);
@@ -38,15 +40,14 @@ public class RemoveRedundantModifierFix extends IntentionActionForPsiElement<Jet
element.replace(RemoveModifierFix.removeModifierFromList(newElement, redundantModifier));
}
public static IntentionActionFactory<JetModifierList> createFactory() {
return new IntentionActionFactory<JetModifierList>() {
public static JetIntentionActionFactory<JetModifierList> createFactory() {
return new JetIntentionActionFactory<JetModifierList>() {
@Override
public IntentionActionForPsiElement<JetModifierList> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetModifierList> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetModifierList;
assert diagnostic instanceof DiagnosticWithAdditionalInfo;
Object info = ((DiagnosticWithAdditionalInfo) diagnostic).getInfo();
assert info instanceof JetKeywordToken;
return new RemoveRedundantModifierFix((JetModifierList) diagnostic.getPsiElement(), (JetKeywordToken) info);
DiagnosticWithParameters<PsiElement> diagnosticWithParameters = assertAndCastToDiagnosticWithParameters(diagnostic, DiagnosticParameters.MODIFIER);
JetKeywordToken modifier = diagnosticWithParameters.getParameter(DiagnosticParameters.MODIFIER);
return new RemoveRedundantModifierFix((JetModifierList) diagnostic.getPsiElement(), modifier);
}
};
}
idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java
+7 -7
View File
@@ -13,7 +13,7 @@ import org.jetbrains.jet.lang.psi.JetExpression;
/**
* @author svtk
*/
public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> extends IntentionActionForPsiElement<T> {
public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpression> extends JetIntentionAction<T> {
public RemoveRightPartOfBinaryExpressionFix(@NotNull T element) {
super(element);
}
@@ -36,10 +36,10 @@ public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpressi
}
}
public static IntentionActionFactory<JetBinaryExpressionWithTypeRHS> createRemoveCastFactory() {
return new IntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
public static JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS> createRemoveCastFactory() {
return new JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement()) {
@NotNull
@@ -52,10 +52,10 @@ public abstract class RemoveRightPartOfBinaryExpressionFix<T extends JetExpressi
};
}
public static IntentionActionFactory<JetBinaryExpression> createRemoveElvisOperatorFactory() {
return new IntentionActionFactory<JetBinaryExpression>() {
public static JetIntentionActionFactory<JetBinaryExpression> createRemoveElvisOperatorFactory() {
return new JetIntentionActionFactory<JetBinaryExpression>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpression> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetBinaryExpression> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpression;
return new RemoveRightPartOfBinaryExpressionFix<JetBinaryExpression>((JetBinaryExpression) diagnostic.getPsiElement()) {
@NotNull
idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java
+4 -4
View File
@@ -14,7 +14,7 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory;
/**
* @author svtk
*/
public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpression> extends IntentionActionForPsiElement<T> {
public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpression> extends JetIntentionAction<T> {
private final String expressionWithNecessaryOperation;
public ReplaceOperationInBinaryExpressionFix(@NotNull T element, String expressionWithNecessaryOperation) {
super(element);
@@ -39,10 +39,10 @@ public abstract class ReplaceOperationInBinaryExpressionFix<T extends JetExpress
}
}
public static IntentionActionFactory<JetBinaryExpressionWithTypeRHS> createChangeCastToStaticAssertFactory() {
return new IntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
public static JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS> createChangeCastToStaticAssertFactory() {
return new JetIntentionActionFactory<JetBinaryExpressionWithTypeRHS>() {
@Override
public IntentionActionForPsiElement<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetBinaryExpressionWithTypeRHS> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetBinaryExpressionWithTypeRHS;
return new ReplaceOperationInBinaryExpressionFix<JetBinaryExpressionWithTypeRHS>((JetBinaryExpressionWithTypeRHS) diagnostic.getPsiElement(), "2 : Int") {
@NotNull
idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceSafeCallToDotCall.java
+5 -4
View File
@@ -12,7 +12,7 @@ import org.jetbrains.jet.lang.psi.*;
/**
* @author svtk
*/
public class ReplaceSafeCallToDotCall extends IntentionActionForPsiElement<JetElement> {
public class ReplaceSafeCallToDotCall extends JetIntentionAction<JetElement> {
public ReplaceSafeCallToDotCall(@NotNull JetElement element) {
super(element);
@@ -36,6 +36,7 @@ public class ReplaceSafeCallToDotCall extends IntentionActionForPsiElement<JetEl
JetSafeQualifiedExpression safeQualifiedExpression = (JetSafeQualifiedExpression) element;
JetDotQualifiedExpression newElement = (JetDotQualifiedExpression) JetPsiFactory.createExpression(project, "x.foo");
//TODO check for null
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getSelectorExpression().getNode(), safeQualifiedExpression.getSelectorExpression().getNode());
CodeEditUtil.replaceChild(newElement.getNode(), newElement.getReceiverExpression().getNode(), safeQualifiedExpression.getReceiverExpression().getNode());
@@ -50,10 +51,10 @@ public class ReplaceSafeCallToDotCall extends IntentionActionForPsiElement<JetEl
}
}
public static IntentionActionFactory<JetElement> createFactory() {
return new IntentionActionFactory<JetElement>() {
public static JetIntentionActionFactory<JetElement> createFactory() {
return new JetIntentionActionFactory<JetElement>() {
@Override
public IntentionActionForPsiElement<JetElement> createAction(DiagnosticWithPsiElement diagnostic) {
public JetIntentionAction<JetElement> createAction(DiagnosticWithPsiElement diagnostic) {
assert diagnostic.getPsiElement() instanceof JetElement;
return new ReplaceSafeCallToDotCall((JetElement) diagnostic.getPsiElement());
}
idea/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java
+31 -38
View File
@@ -349,59 +349,52 @@ public class JetDefaultModalityModifiersTest extends LightDaemonAnalyzerTestCase
tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("class A : C { final override val a: Int = 0; override get() = 2 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; get }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; open get }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; override get() = 2 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; get }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; open get }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; override get() = 2 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { open override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; override get() = 2 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("open class A : C { final override val a: Int = 0; final override get() = 2 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { abstract override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int override get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int open override get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A : C { override val a: Int final override get() = 10 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open abstract override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int override get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int open override get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A : C { open override val a: Int final override get() = 10 }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int = 0; get }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A : C { abstract override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A : C { abstract override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { abstract override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { abstract override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { abstract override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { abstract override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { override val a: Int get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A { override val a: Int open get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A { override val a: Int final get() = 10 }", Modality.FINAL);
tc.testPropertyAccessorModalityInClass("abstract class A { open abstract override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { open abstract override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { open abstract override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { open abstract override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInClass("abstract class A { open override val a: Int get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A { open override val a: Int open get() = 10 }", Modality.OPEN);
tc.testPropertyAccessorModalityInClass("abstract class A { open override val a: Int final get() = 10 }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int open get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("trait A { override val a: Int final get() = 1 }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int open get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("abstract trait A { override val a: Int final get() = 1 }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int override get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int abstract get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int open get }", Modality.ABSTRACT);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int open override get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int override get() = 1 }", Modality.OPEN);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int final get }", Modality.FINAL);
tc.testPropertyAccessorModalityInTrait("trait A : C { override val a: Int final override get() = 1 }", Modality.FINAL);
}
}