From aac7f84c2522bea1b7515031ec9ca03f32ff10f4 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 13 May 2013 16:21:19 +0400 Subject: [PATCH 01/92] Fix absence of implemented/overridden markers on overridden functions --- .../highlighter/JetLineMarkerProvider.java | 11 +++++------ .../codeInsight/lineMarker/OverrideFunction.kt | 16 ++++++++++++++++ .../OverrideImplementLineMarkerTest.java | 4 ++++ 3 files changed, 25 insertions(+), 6 deletions(-) create mode 100644 idea/testData/codeInsight/lineMarker/OverrideFunction.kt diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index a6e84447bdf..25577f783f3 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -34,6 +34,7 @@ import com.intellij.openapi.project.DumbService; import com.intellij.openapi.ui.popup.JBPopup; import com.intellij.openapi.ui.popup.JBPopupFactory; import com.intellij.openapi.util.Pair; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.CommonClassNames; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; @@ -255,15 +256,12 @@ public class JetLineMarkerProvider implements LineMarkerProvider { builder.append(DescriptorRenderer.HTML.render(descriptor)); int overrideCount = overriddenMembers.size(); if (overrideCount >= 1) { - builder.append("\n").append(implementsOrOverrides).append("\n"); + builder.append("
").append(implementsOrOverrides).append("
"); builder.append(DescriptorRenderer.HTML.render(overriddenMembers.iterator().next())); } if (overrideCount > 1) { - int count = overrideCount - 1; - builder.append("\nand ").append(count).append(" other ").append(memberKind); - if (count > 1) { - builder.append("s"); - } + int otherCount = overrideCount - 1; + builder.append("
and ").append(otherCount).append(" other ").append(StringUtil.pluralize(memberKind, otherCount)); } return builder.toString(); @@ -318,6 +316,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { // Not all open or abstract declarations are actually overridable, but this is heuristic return declaration.hasModifier(JetTokens.ABSTRACT_KEYWORD) || declaration.hasModifier(JetTokens.OPEN_KEYWORD) || + declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD) || ((JetClass) parent.getParent()).isTrait(); } diff --git a/idea/testData/codeInsight/lineMarker/OverrideFunction.kt b/idea/testData/codeInsight/lineMarker/OverrideFunction.kt new file mode 100644 index 00000000000..ee4a54cac32 --- /dev/null +++ b/idea/testData/codeInsight/lineMarker/OverrideFunction.kt @@ -0,0 +1,16 @@ +open class A { + open fun a(){ + } +} + +open class B:A(){ + override fun a(){ + } +} + +class C:B(){ + override fun a(){ + } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java index 2b52ed5f21d..1d5c0fe2bde 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java @@ -42,6 +42,10 @@ public class OverrideImplementLineMarkerTest extends LightCodeInsightFixtureTest doTest(); } + public void testOverrideFunction() throws Throwable { + doTest(); + } + private void doTest() { try { myFixture.configureByFile(getTestName(false) + ".kt"); From 8752b417e594fcbaf446e35dc373b2fe106e128c Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 26 Apr 2013 18:37:20 +0400 Subject: [PATCH 02/92] Refactoring: extract methods --- .../search/KotlinDefinitionsSearcher.java | 44 +++++++++++-------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index ecbd25dd5e1..6b3d2837d87 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -33,30 +33,38 @@ import org.jetbrains.jet.lang.psi.JetNamedFunction; public class KotlinDefinitionsSearcher extends QueryExecutorBase { @Override - public void processQuery(@NotNull final PsiElement queryParameters, @NotNull Processor consumer) { + public void processQuery(@NotNull PsiElement queryParameters, @NotNull Processor consumer) { if (queryParameters instanceof JetClass) { - PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable() { - @Override - public PsiClass compute() { - return LightClassUtil.getPsiClass((JetClass) queryParameters); - } - }); - if (psiClass != null) { - ContainerUtil.process(ClassInheritorsSearch.search(psiClass, true), consumer); - } + processClassImplementations((JetClass) queryParameters, consumer); } if (queryParameters instanceof JetNamedFunction) { - PsiMethod psiMethod = ApplicationManager.getApplication().runReadAction(new Computable() { - @Override - public PsiMethod compute() { - return LightClassUtil.getLightClassMethod((JetNamedFunction) queryParameters); - } - }); + processFunctionImplementations((JetNamedFunction) queryParameters, consumer); + } + } - if (psiMethod != null) { - ContainerUtil.process(MethodImplementationsSearch.getMethodImplementations(psiMethod), consumer); + private static void processClassImplementations(final JetClass queryParameters, Processor consumer) { + PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable() { + @Override + public PsiClass compute() { + return LightClassUtil.getPsiClass(queryParameters); } + }); + if (psiClass != null) { + ContainerUtil.process(ClassInheritorsSearch.search(psiClass, true), consumer); + } + } + + private static void processFunctionImplementations(final JetNamedFunction queryParameters, Processor consumer) { + PsiMethod psiMethod = ApplicationManager.getApplication().runReadAction(new Computable() { + @Override + public PsiMethod compute() { + return LightClassUtil.getLightClassMethod(queryParameters); + } + }); + + if (psiMethod != null) { + ContainerUtil.process(MethodImplementationsSearch.getMethodImplementations(psiMethod), consumer); } } } From cef1bb2aba352e97baaf04c75b22bc89f64d47ad Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 8 May 2013 12:31:00 +0400 Subject: [PATCH 03/92] Add test for wrapping function without body --- idea/testData/javaFacade/wrapFunInClassWithoutBody.kt | 5 +++++ .../jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java | 4 ++++ 2 files changed, 9 insertions(+) create mode 100644 idea/testData/javaFacade/wrapFunInClassWithoutBody.kt diff --git a/idea/testData/javaFacade/wrapFunInClassWithoutBody.kt b/idea/testData/javaFacade/wrapFunInClassWithoutBody.kt new file mode 100644 index 00000000000..4fc3ec14070 --- /dev/null +++ b/idea/testData/javaFacade/wrapFunInClassWithoutBody.kt @@ -0,0 +1,5 @@ +package some + +open class Hello { + open fun hello() = "DoSomething" +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index fbdae321873..2b91d146ee7 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -51,6 +51,10 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { doTestWrapMethod(false); } + public void testWrapFunInClassWithoutBody() { + doTestWrapMethod(true); + } + public void testWrapFunInClassObject() { doTestWrapMethod(true); } From d97ab295886151496e604204bb9de3e20e9db2a7 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 19:08:06 +0400 Subject: [PATCH 04/92] Add test for wrapping function with default parameters --- idea/testData/javaFacade/wrapTopLevelFunWithDefaultParams.kt | 3 +++ .../jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java | 4 ++++ 2 files changed, 7 insertions(+) create mode 100644 idea/testData/javaFacade/wrapTopLevelFunWithDefaultParams.kt diff --git a/idea/testData/javaFacade/wrapTopLevelFunWithDefaultParams.kt b/idea/testData/javaFacade/wrapTopLevelFunWithDefaultParams.kt new file mode 100644 index 00000000000..dec6cd76068 --- /dev/null +++ b/idea/testData/javaFacade/wrapTopLevelFunWithDefaultParams.kt @@ -0,0 +1,3 @@ +fun test(some: Int = 12) { + println(some) +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index 2b91d146ee7..29d19e723a7 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -95,6 +95,10 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { doTestWrapClass(); } + public void testWrapTopLevelFunWithDefaultParams() { + doTestWrapMethod(true); + } + public void testEa38770() { myFixture.configureByFile(getTestName(true) + ".kt"); From 312bd6f828ad0664ad2176771a6769f9f3b6e6a6 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 19:07:53 +0400 Subject: [PATCH 05/92] Get PsiMethod wrappers for properties and property accessors --- .../jetbrains/jet/asJava/LightClassUtil.java | 180 ++++++++++++++---- .../javaFacade/wrapValTopLevelProperty.kt | 1 + .../javaFacade/wrapVarPropertyInClass.kt | 3 + .../javaFacade/wrapVarPropertyInLocalClass.kt | 5 + .../wrapVarPropertyWithAccessorsInTrait.kt | 5 + .../javaFacade/wrapVarTopLevelAccessor.kt | 3 + .../javaFacade/wrapVarTopLevelProperty.kt | 1 + .../plugin/javaFacade/JetJavaFacadeTest.java | 74 ++++++- 8 files changed, 225 insertions(+), 47 deletions(-) create mode 100644 idea/testData/javaFacade/wrapValTopLevelProperty.kt create mode 100644 idea/testData/javaFacade/wrapVarPropertyInClass.kt create mode 100644 idea/testData/javaFacade/wrapVarPropertyInLocalClass.kt create mode 100644 idea/testData/javaFacade/wrapVarPropertyWithAccessorsInTrait.kt create mode 100644 idea/testData/javaFacade/wrapVarTopLevelAccessor.kt create mode 100644 idea/testData/javaFacade/wrapVarTopLevelProperty.kt diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java index 686b92d5cc9..04104a33439 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java @@ -31,10 +31,13 @@ import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.stubs.PsiFileStub; import com.intellij.psi.stubs.StubElement; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.SmartList; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.java.JetClsMethod; +import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -42,6 +45,7 @@ import org.jetbrains.jet.utils.KotlinVfsUtil; import java.net.MalformedURLException; import java.net.URL; +import java.util.*; public class LightClassUtil { private static final Logger LOG = Logger.getInstance(LightClassUtil.class); @@ -116,42 +120,70 @@ public class LightClassUtil { return LightClassGenerationSupport.getInstance(classOrObject.getProject()).getPsiClass(classOrObject); } + @Nullable + public static PsiMethod getLightClassAccessorMethod(@NotNull JetPropertyAccessor accessor) { + return getPsiMethodWrapper(accessor); + } + + @NotNull + public static PropertyAccessorsPsiMethods getLightClassPropertyMethods(@NotNull JetProperty property) { + JetPropertyAccessor getter = property.getGetter(); + JetPropertyAccessor setter = property.getSetter(); + + PsiMethod getterWrapper = getter != null ? getLightClassAccessorMethod(getter) : null; + PsiMethod setterWrapper = setter != null ? getLightClassAccessorMethod(setter) : null; + + if (getterWrapper == null || setterWrapper == null) { + List wrappers = getPsiMethodWrappers(property, true); + assert wrappers.size() <= 2 : "Maximum two wrappers are expected to be generated for property"; + + for (PsiMethod wrapper : wrappers) { + if (wrapper.getName().startsWith(JvmAbi.SETTER_PREFIX)) { + assert setterWrapper == null : String.format( + "Setter accessor isn't expected to be reassigned (old: %s, new: %s)", setterWrapper, wrapper); + + setterWrapper = wrapper; + } + else { + assert getterWrapper == null : String.format( + "Getter accessor isn't expected to be reassigned (old: %s, new: %s)", getterWrapper, wrapper); + + getterWrapper = wrapper; + } + } + } + + return new PropertyAccessorsPsiMethods(getterWrapper, setterWrapper); + } + @Nullable public static PsiMethod getLightClassMethod(@NotNull JetNamedFunction function) { - //noinspection unchecked - if (PsiTreeUtil.getParentOfType(function, JetFunction.class, JetProperty.class) != null) { - // Don't genClassOrObject method wrappers for internal declarations. Their classes are not generated during calcStub - // with ClassBuilderMode.SIGNATURES mode, and this produces "Class not found exception" in getDelegate() - return null; + return getPsiMethodWrapper(function); + } + + @Nullable + private static PsiMethod getPsiMethodWrapper(@NotNull JetDeclaration declaration) { + List wrappers = getPsiMethodWrappers(declaration, false); + return !wrappers.isEmpty() ? wrappers.get(0) : null; + } + + @NotNull + private static List getPsiMethodWrappers(@NotNull JetDeclaration declaration, boolean collectAll) { + PsiClass psiClass = getWrappingClass(declaration); + if (psiClass == null) { + return Collections.emptyList(); } - Project project = function.getProject(); - - PsiElement parent = function.getParent(); - PsiClass psiClass; - if (parent == function.getContainingFile()) { - // top-level function - JvmClassName jvmClassName = PsiCodegenPredictor.getPredefinedJvmClassName((JetFile) parent, true); - if (jvmClassName == null) return null; - - String fqName = jvmClassName.getFqName().getFqName(); - psiClass = JavaElementFinder.getInstance(project).findClass(fqName, GlobalSearchScope.allScope(project)); - } - else { - if (!(parent instanceof JetClassBody)) return null; - assert parent.getParent() instanceof JetClassOrObject; - - // function in a class - JetClassOrObject classOrObject = (JetClassOrObject) parent.getParent(); - psiClass = getPsiClass(classOrObject); - } - - if (psiClass == null) return null; - + List methods = new SmartList(); for (PsiMethod method : psiClass.getMethods()) { try { - if (method instanceof PsiCompiledElement && ((PsiCompiledElement) method).getMirror() == function) { - return method; + if (method instanceof JetClsMethod) { + if (method instanceof PsiCompiledElement && ((PsiCompiledElement) method).getMirror() == declaration) { + methods.add(method); + if (!collectAll) { + return methods; + } + } } } catch (ProcessCanceledException e) { @@ -159,24 +191,94 @@ public class LightClassUtil { } catch (Throwable e) { throw new IllegalStateException( - "Error while wrapping function " + function.getName() + + "Error while wrapping declaration " + declaration.getName() + "Context\n:" + String.format("=== In file ===\n" + - "%s\n" + - "===On element===\n" + - "%s\n" + - "===WrappedElement===\n" + - "%s\n", - function.getContainingFile().getText(), - function.getText(), - method.toString()), + "%s\n" + + "=== On element ===\n" + + "%s\n" + + "=== WrappedElement ===\n" + + "%s\n", + declaration.getContainingFile().getText(), + declaration.getText(), + method.toString()), e ); } } + return methods; + } + + @Nullable + private static PsiClass getWrappingClass(@NotNull JetDeclaration declaration) { + if (declaration instanceof JetPropertyAccessor) { + PsiElement propertyParent = declaration.getParent(); + assert propertyParent instanceof JetProperty : "JetProperty is expected to be parent of accessor"; + + declaration = (JetProperty) propertyParent; + } + + //noinspection unchecked + if (PsiTreeUtil.getParentOfType(declaration, JetFunction.class, JetProperty.class) != null) { + // Can't get wrappers for internal declarations. Their classes are not generated during calcStub + // with ClassBuilderMode.SIGNATURES mode, and this produces "Class not found exception" in getDelegate() + return null; + } + + PsiElement parent = declaration.getParent(); + + if (parent instanceof JetFile) { + // top-level declaration + JvmClassName jvmName = PsiCodegenPredictor.getPredefinedJvmClassName((JetFile) parent, true); + if (jvmName != null) { + Project project = declaration.getProject(); + + String fqName = jvmName.getFqName().getFqName(); + return JavaElementFinder.getInstance(project).findClass(fqName, GlobalSearchScope.allScope(project)); + } + } + else if (parent instanceof JetClassBody) { + assert parent.getParent() instanceof JetClassOrObject; + return getPsiClass((JetClassOrObject) parent.getParent()); + } + return null; } + public static class PropertyAccessorsPsiMethods implements Iterable { + private final PsiMethod getter; + private final PsiMethod setter; + private final Collection accessors = new ArrayList(2); + + PropertyAccessorsPsiMethods(@Nullable PsiMethod getter, @Nullable PsiMethod setter) { + this.getter = getter; + if (getter != null) { + accessors.add(getter); + } + + this.setter = setter; + if (setter != null) { + accessors.add(setter); + } + } + + @Nullable + public PsiMethod getGetter() { + return getter; + } + + @Nullable + public PsiMethod getSetter() { + return setter; + } + + @NotNull + @Override + public Iterator iterator() { + return accessors.iterator(); + } + } + private LightClassUtil() {} } diff --git a/idea/testData/javaFacade/wrapValTopLevelProperty.kt b/idea/testData/javaFacade/wrapValTopLevelProperty.kt new file mode 100644 index 00000000000..5d903b0a451 --- /dev/null +++ b/idea/testData/javaFacade/wrapValTopLevelProperty.kt @@ -0,0 +1 @@ +val test: Int? = null \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapVarPropertyInClass.kt b/idea/testData/javaFacade/wrapVarPropertyInClass.kt new file mode 100644 index 00000000000..8aaf0e814fe --- /dev/null +++ b/idea/testData/javaFacade/wrapVarPropertyInClass.kt @@ -0,0 +1,3 @@ +class Test { + var test = "Test" +} \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapVarPropertyInLocalClass.kt b/idea/testData/javaFacade/wrapVarPropertyInLocalClass.kt new file mode 100644 index 00000000000..e89a96f78cf --- /dev/null +++ b/idea/testData/javaFacade/wrapVarPropertyInLocalClass.kt @@ -0,0 +1,5 @@ +fun test() { + class Test { + var someProperty = "No wrapper is expected" + } +} \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapVarPropertyWithAccessorsInTrait.kt b/idea/testData/javaFacade/wrapVarPropertyWithAccessorsInTrait.kt new file mode 100644 index 00000000000..9b324ad7dc7 --- /dev/null +++ b/idea/testData/javaFacade/wrapVarPropertyWithAccessorsInTrait.kt @@ -0,0 +1,5 @@ +trait Hello { + var some: String + get() = "Hi" + set(value) {} +} \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapVarTopLevelAccessor.kt b/idea/testData/javaFacade/wrapVarTopLevelAccessor.kt new file mode 100644 index 00000000000..f8ae61889b9 --- /dev/null +++ b/idea/testData/javaFacade/wrapVarTopLevelAccessor.kt @@ -0,0 +1,3 @@ +var some: String + get() = "Hi" + set(value) {} diff --git a/idea/testData/javaFacade/wrapVarTopLevelProperty.kt b/idea/testData/javaFacade/wrapVarTopLevelProperty.kt new file mode 100644 index 00000000000..c242b701c67 --- /dev/null +++ b/idea/testData/javaFacade/wrapVarTopLevelProperty.kt @@ -0,0 +1 @@ +var test: Int? = null \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index 29d19e723a7..8f444c4fa6e 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -24,8 +24,7 @@ import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.asJava.LightClassUtil; -import org.jetbrains.jet.lang.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.PluginTestCaseBase; @@ -99,6 +98,30 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { doTestWrapMethod(true); } + public void testWrapValTopLevelProperty() { + doTestWrapProperty(true, false); + } + + public void testWrapVarPropertyInClass() { + doTestWrapProperty(true, true); + } + + public void testWrapVarPropertyWithAccessorsInTrait() { + doTestWrapProperty(true, true); + } + + public void testWrapVarTopLevelProperty() { + doTestWrapProperty(true, true); + } + + public void testWrapVarPropertyInLocalClass() { + doTestWrapProperty(false, false); + } + + public void testWrapVarTopLevelAccessor() { + doTestWrapPropertyAccessor(true); + } + public void testEa38770() { myFixture.configureByFile(getTestName(true) + ".kt"); @@ -166,6 +189,37 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } private void doTestWrapMethod(boolean shouldBeWrapped) { + JetNamedFunction jetFunction = getPreparedElement(JetNamedFunction.class); + + // Should not fail! + PsiMethod psiMethod = LightClassUtil.getLightClassMethod(jetFunction); + + checkDeclarationMethodWrapped(shouldBeWrapped, jetFunction, psiMethod); + } + + private void doTestWrapProperty(boolean shouldWrapGetter, boolean shouldWrapSetter) { + JetProperty jetProperty = getPreparedElement(JetProperty.class); + + // Should not fail! + LightClassUtil.PropertyAccessorsPsiMethods propertyAccessors = LightClassUtil.getLightClassPropertyMethods(jetProperty); + + JetPropertyAccessor getter = jetProperty.getGetter(); + JetPropertyAccessor setter = jetProperty.getSetter(); + + checkDeclarationMethodWrapped(shouldWrapGetter, getter != null ? getter : jetProperty, propertyAccessors.getGetter()); + checkDeclarationMethodWrapped(shouldWrapSetter, setter != null ? setter : jetProperty, propertyAccessors.getSetter()); + } + + private void doTestWrapPropertyAccessor(boolean shouldWrapAccessor) { + JetPropertyAccessor jetPropertyAccessor = getPreparedElement(JetPropertyAccessor.class); + + // Should not fail! + PsiMethod propertyAccessors = LightClassUtil.getLightClassAccessorMethod(jetPropertyAccessor); + checkDeclarationMethodWrapped(shouldWrapAccessor, jetPropertyAccessor, propertyAccessors); + } + + @NotNull + private T getPreparedElement(Class elementClass) { myFixture.configureByFile(getTestName(true) + ".kt"); int offset = myFixture.getEditor().getCaretModel().getOffset(); @@ -173,16 +227,20 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { assertNotNull("Caret should be set for tested file", elementAt); - JetNamedFunction jetFunction = PsiTreeUtil.getParentOfType(elementAt, JetNamedFunction.class); - assertNotNull("Caret should be placed to function definition", jetFunction); + T caretElement = PsiTreeUtil.getParentOfType(elementAt, elementClass); + assertNotNull( + String.format("Caret should be placed to element of type: %s, but was at element '%s' of type %s", + elementClass, elementAt, elementAt.getClass()), + caretElement); - // Should not fail! - PsiMethod psiMethod = LightClassUtil.getLightClassMethod(jetFunction); + return caretElement; + } + private static void checkDeclarationMethodWrapped(boolean shouldBeWrapped, JetDeclaration declaration, PsiMethod psiMethod) { if (shouldBeWrapped) { - assertNotNull(String.format("Failed to wrap jetFunction '%s' to method", jetFunction.getText()), psiMethod); + assertNotNull(String.format("Failed to wrap declaration '%s' to method", declaration.getText()), psiMethod); assertInstanceOf(psiMethod, PsiCompiledElement.class); - assertEquals("Invalid original element for generated method", ((PsiCompiledElement) psiMethod).getMirror(), jetFunction); + assertEquals("Invalid original element for generated method", ((PsiCompiledElement) psiMethod).getMirror(), declaration); } else { assertNull("There should be no wrapper for given method", psiMethod); From 5cc49f55f36e5fd78d763a9b927cba91e99fbeec Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 26 Apr 2013 18:38:43 +0400 Subject: [PATCH 06/92] KT-3542 Can't navigate to property implementation #KT-3542 Fixed --- .../search/KotlinDefinitionsSearcher.java | 33 +++++++++++++++++++ .../PropertyOverriddenNavigation.kt | 17 ++++++++++ .../ImplementVarInJava.java | 11 +++++++ .../ImplementVarInJava/ImplementVarInJava.kt | 8 +++++ .../JetGotoImplementationMultifileTest.java | 4 +++ .../navigation/JetGotoImplementationTest.java | 4 +++ 6 files changed, 77 insertions(+) create mode 100644 idea/testData/navigation/implementations/PropertyOverriddenNavigation.kt create mode 100644 idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.java create mode 100644 idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.kt diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index 6b3d2837d87..950032e1fbe 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -21,6 +21,7 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.QueryExecutorBase; import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiCompiledElement; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.search.searches.ClassInheritorsSearch; @@ -30,6 +31,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.psi.JetPropertyAccessor; public class KotlinDefinitionsSearcher extends QueryExecutorBase { @Override @@ -41,6 +44,10 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { @@ -67,4 +74,30 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { + LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction( + new Computable() { + @Override + public LightClassUtil.PropertyAccessorsPsiMethods compute() { + return LightClassUtil.getLightClassPropertyMethods(property); + } + }); + + for (PsiMethod method : accessorsPsiMethods) { + PsiMethod[] implementations = MethodImplementationsSearch.getMethodImplementations(method); + for (PsiMethod implementation : implementations) { + PsiElement mirrorElement = implementation instanceof PsiCompiledElement ? ((PsiCompiledElement) implementation).getMirror() : null; + if (mirrorElement instanceof JetProperty) { + consumer.process(mirrorElement); + } + else if (mirrorElement instanceof JetPropertyAccessor && mirrorElement.getParent() instanceof JetProperty) { + consumer.process(mirrorElement.getParent()); + } + else { + consumer.process(implementation); + } + } + } + } } diff --git a/idea/testData/navigation/implementations/PropertyOverriddenNavigation.kt b/idea/testData/navigation/implementations/PropertyOverriddenNavigation.kt new file mode 100644 index 00000000000..31ed7520492 --- /dev/null +++ b/idea/testData/navigation/implementations/PropertyOverriddenNavigation.kt @@ -0,0 +1,17 @@ +package testing + +open class Base { + open var test = 12 +} + +open class SubBase: Base() { + override var test = 12 +} + +class SubSubBase: SubBase() { + override var test = 12 +} + + +// REF: (testing.SubBase).test +// REF: (testing.SubSubBase).test \ No newline at end of file diff --git a/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.java b/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.java new file mode 100644 index 00000000000..9cec2ab5d00 --- /dev/null +++ b/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.java @@ -0,0 +1,11 @@ +package testing.jj; + +public class JavaBase extends testing.kt.KotlinBase { + @Override + public String getSome() { + } + + @Override + public void setSome(String someValue) { + } +} \ No newline at end of file diff --git a/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.kt b/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.kt new file mode 100644 index 00000000000..c1d0b9b8540 --- /dev/null +++ b/idea/testData/navigation/implementations/multifile/ImplementVarInJava/ImplementVarInJava.kt @@ -0,0 +1,8 @@ +package testing.kt + +open class KotlinBase { + open var some = "Test" +} + +// REF: (in testing.jj.JavaBase).getSome() +// REF: (in testing.jj.JavaBase).setSome(String) \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationMultifileTest.java b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationMultifileTest.java index ed6d73c4299..22fc50b54cf 100644 --- a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationMultifileTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationMultifileTest.java @@ -39,6 +39,10 @@ public class JetGotoImplementationMultifileTest extends CodeInsightTestCase { doKotlinJavaTest(); } + public void testImplementVarInJava() throws Exception { + doKotlinJavaTest(); + } + private void doKotlinJavaTest() throws Exception { doMultifileTest(getTestName(false) + ".kt", getTestName(false) + ".java"); } diff --git a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java index a863e867bbd..27e2f18ef46 100644 --- a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java @@ -37,6 +37,10 @@ public class JetGotoImplementationTest extends LightCodeInsightTestCase { doTest(); } + public void testPropertyOverriddenNavigation() { + doTest(); + } + @NotNull @Override protected String getTestDataPath() { From 0a2ca39f88e50522bdcfbeee3c3ce2e65ec1c44d Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 14 May 2013 01:09:51 +0400 Subject: [PATCH 07/92] Search implementations for properties from constructor parameters --- .../jetbrains/jet/asJava/LightClassUtil.java | 60 ++++++++++++------- .../search/KotlinDefinitionsSearcher.java | 32 ++++++++-- .../javaFacade/wrapConstructorField.kt | 1 + .../javaFacade/wrapConstructorParameter.kt | 1 + .../javaFacade/wrapFunctionParameter.kt | 1 + .../plugin/javaFacade/JetJavaFacadeTest.java | 22 +++++++ 6 files changed, 91 insertions(+), 26 deletions(-) create mode 100644 idea/testData/javaFacade/wrapConstructorField.kt create mode 100644 idea/testData/javaFacade/wrapConstructorParameter.kt create mode 100644 idea/testData/javaFacade/wrapFunctionParameter.kt diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java index 04104a33439..7ef41f7d4c3 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java @@ -133,27 +133,11 @@ public class LightClassUtil { PsiMethod getterWrapper = getter != null ? getLightClassAccessorMethod(getter) : null; PsiMethod setterWrapper = setter != null ? getLightClassAccessorMethod(setter) : null; - if (getterWrapper == null || setterWrapper == null) { - List wrappers = getPsiMethodWrappers(property, true); - assert wrappers.size() <= 2 : "Maximum two wrappers are expected to be generated for property"; + return extractPropertyAccessors(property, getterWrapper, setterWrapper); + } - for (PsiMethod wrapper : wrappers) { - if (wrapper.getName().startsWith(JvmAbi.SETTER_PREFIX)) { - assert setterWrapper == null : String.format( - "Setter accessor isn't expected to be reassigned (old: %s, new: %s)", setterWrapper, wrapper); - - setterWrapper = wrapper; - } - else { - assert getterWrapper == null : String.format( - "Getter accessor isn't expected to be reassigned (old: %s, new: %s)", getterWrapper, wrapper); - - getterWrapper = wrapper; - } - } - } - - return new PropertyAccessorsPsiMethods(getterWrapper, setterWrapper); + public static PropertyAccessorsPsiMethods getLightClassPropertyMethods(@NotNull JetParameter parameter) { + return extractPropertyAccessors(parameter, null, null); } @Nullable @@ -212,6 +196,10 @@ public class LightClassUtil { @Nullable private static PsiClass getWrappingClass(@NotNull JetDeclaration declaration) { + if (declaration instanceof JetParameter && declaration.getParent().getParent() instanceof JetClass) { + return getPsiClass((JetClassOrObject) declaration.getParent().getParent()); + } + if (declaration instanceof JetPropertyAccessor) { PsiElement propertyParent = declaration.getParent(); assert propertyParent instanceof JetProperty : "JetProperty is expected to be parent of accessor"; @@ -246,6 +234,38 @@ public class LightClassUtil { return null; } + private static PropertyAccessorsPsiMethods extractPropertyAccessors( + @NotNull JetDeclaration jetDeclaration, + @Nullable PsiMethod specialGetter, @Nullable PsiMethod specialSetter) + { + PsiMethod getterWrapper = specialGetter; + PsiMethod setterWrapper = specialSetter; + + if (getterWrapper == null || setterWrapper == null) { + // If some getter or setter isn't found yet try to get it from wrappers for general declaration + + List wrappers = getPsiMethodWrappers(jetDeclaration, true); + assert wrappers.size() <= 2 : "Maximum two wrappers are expected to be generated for declaration: " + jetDeclaration.getText(); + + for (PsiMethod wrapper : wrappers) { + if (wrapper.getName().startsWith(JvmAbi.SETTER_PREFIX)) { + assert setterWrapper == null : String.format( + "Setter accessor isn't expected to be reassigned (old: %s, new: %s)", setterWrapper, wrapper); + + setterWrapper = wrapper; + } + else { + assert getterWrapper == null : String.format( + "Getter accessor isn't expected to be reassigned (old: %s, new: %s)", getterWrapper, wrapper); + + getterWrapper = wrapper; + } + } + } + + return new PropertyAccessorsPsiMethods(getterWrapper, setterWrapper); + } + public static class PropertyAccessorsPsiMethods implements Iterable { private final PsiMethod getter; private final PsiMethod setter; diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index 950032e1fbe..89980b7611d 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -29,10 +29,7 @@ import com.intellij.util.Processor; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.LightClassUtil; -import org.jetbrains.jet.lang.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetProperty; -import org.jetbrains.jet.lang.psi.JetPropertyAccessor; +import org.jetbrains.jet.lang.psi.*; public class KotlinDefinitionsSearcher extends QueryExecutorBase { @Override @@ -48,6 +45,13 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { @@ -75,6 +79,18 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { + LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction( + new Computable() { + @Override + public LightClassUtil.PropertyAccessorsPsiMethods compute() { + return LightClassUtil.getLightClassPropertyMethods(parameter); + } + }); + + processPropertyImplementationsMethods(accessorsPsiMethods, consumer); + } + private static void processPropertyImplementations(@NotNull final JetProperty property, @NotNull Processor consumer) { LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction( new Computable() { @@ -84,11 +100,15 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { + for (PsiMethod method : accessors) { PsiMethod[] implementations = MethodImplementationsSearch.getMethodImplementations(method); for (PsiMethod implementation : implementations) { PsiElement mirrorElement = implementation instanceof PsiCompiledElement ? ((PsiCompiledElement) implementation).getMirror() : null; - if (mirrorElement instanceof JetProperty) { + if (mirrorElement instanceof JetProperty || mirrorElement instanceof JetParameter) { consumer.process(mirrorElement); } else if (mirrorElement instanceof JetPropertyAccessor && mirrorElement.getParent() instanceof JetProperty) { diff --git a/idea/testData/javaFacade/wrapConstructorField.kt b/idea/testData/javaFacade/wrapConstructorField.kt new file mode 100644 index 00000000000..37419fc3881 --- /dev/null +++ b/idea/testData/javaFacade/wrapConstructorField.kt @@ -0,0 +1 @@ +class Test(var field: Int) \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapConstructorParameter.kt b/idea/testData/javaFacade/wrapConstructorParameter.kt new file mode 100644 index 00000000000..87fcd86a1f0 --- /dev/null +++ b/idea/testData/javaFacade/wrapConstructorParameter.kt @@ -0,0 +1 @@ +class Test(var field: Int, parameter: Int) \ No newline at end of file diff --git a/idea/testData/javaFacade/wrapFunctionParameter.kt b/idea/testData/javaFacade/wrapFunctionParameter.kt new file mode 100644 index 00000000000..68f96dab810 --- /dev/null +++ b/idea/testData/javaFacade/wrapFunctionParameter.kt @@ -0,0 +1 @@ +fun testFun(parameter: Int) = 0 \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index 8f444c4fa6e..a43fd97d429 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -122,6 +122,18 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { doTestWrapPropertyAccessor(true); } + public void testWrapConstructorField() { + doTestWrapParameter(true, true); + } + + public void testWrapConstructorParameter() { + doTestWrapParameter(false, false); + } + + public void testWrapFunctionParameter() { + doTestWrapParameter(false, false); + } + public void testEa38770() { myFixture.configureByFile(getTestName(true) + ".kt"); @@ -197,6 +209,16 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { checkDeclarationMethodWrapped(shouldBeWrapped, jetFunction, psiMethod); } + private void doTestWrapParameter(boolean shouldWrapGetter, boolean shouldWrapSetter) { + JetParameter jetParameter = getPreparedElement(JetParameter.class); + + // Should not fail! + LightClassUtil.PropertyAccessorsPsiMethods propertyAccessors = LightClassUtil.getLightClassPropertyMethods(jetParameter); + + checkDeclarationMethodWrapped(shouldWrapGetter, jetParameter, propertyAccessors.getGetter()); + checkDeclarationMethodWrapped(shouldWrapSetter, jetParameter, propertyAccessors.getSetter()); + } + private void doTestWrapProperty(boolean shouldWrapGetter, boolean shouldWrapSetter) { JetProperty jetProperty = getPreparedElement(JetProperty.class); From 3c087965f108a44bbffc92f6a999f1e64d85e619 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 8 May 2013 18:15:55 +0400 Subject: [PATCH 08/92] Add presentation renderer for field declared in constructor --- .../jetbrains/jet/lang/psi/JetParameter.java | 7 ++++- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 7 ++++- idea/src/META-INF/plugin.xml | 2 ++ .../presentation/JetParameterPresenter.java | 28 +++++++++++++++++++ ...ConstructorPropertyOverriddenNavigation.kt | 12 ++++++++ .../navigation/JetGotoImplementationTest.java | 4 +++ 6 files changed, 58 insertions(+), 2 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/presentation/JetParameterPresenter.java create mode 100644 idea/testData/navigation/implementations/ConstructorPropertyOverriddenNavigation.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java index 58ed3e5bf89..296ef03e3f4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java @@ -17,6 +17,8 @@ package org.jetbrains.jet.lang.psi; import com.intellij.lang.ASTNode; +import com.intellij.navigation.ItemPresentation; +import com.intellij.navigation.ItemPresentationProviders; import com.intellij.psi.stubs.IStubElementType; import com.intellij.util.ArrayFactory; import org.jetbrains.annotations.NotNull; @@ -107,5 +109,8 @@ public class JetParameter extends JetNamedDeclarationStub { return getNode().findChildByType(JetTokens.VAR_KEYWORD); } - + @Override + public ItemPresentation getPresentation() { + return ItemPresentationProviders.getItemPresentation(this); + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 865bcc2622d..3228d0f9e32 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -196,11 +196,16 @@ public class JetPsiUtil { else if (parent instanceof JetNamedFunction || parent instanceof JetClass) { firstPart = getFQName((JetNamedDeclaration) parent); } + else if (namedDeclaration instanceof JetParameter) { + if (((JetParameter) namedDeclaration).getValOrVarNode() != null && parent != null && parent.getParent() instanceof JetClassOrObject) { + firstPart = getFQName((JetClassOrObject) parent.getParent()); + } + } else if (parent instanceof JetObjectDeclaration) { if (parent.getParent() instanceof JetClassObject) { JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(parent, JetClassOrObject.class); if (classOrObject != null) { - firstPart = getFQName((JetNamedDeclaration) classOrObject); + firstPart = getFQName(classOrObject); } } else { diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index a942b5d6e55..f1e7fd11e46 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -219,6 +219,8 @@ forClass="org.jetbrains.jet.lang.psi.JetClass"/> + diff --git a/idea/src/org/jetbrains/jet/plugin/presentation/JetParameterPresenter.java b/idea/src/org/jetbrains/jet/plugin/presentation/JetParameterPresenter.java new file mode 100644 index 00000000000..54b34f3be1a --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/presentation/JetParameterPresenter.java @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.presentation; + +import com.intellij.navigation.ItemPresentation; +import com.intellij.navigation.ItemPresentationProvider; +import org.jetbrains.jet.lang.psi.JetParameter; + +public class JetParameterPresenter implements ItemPresentationProvider { + @Override + public ItemPresentation getPresentation(JetParameter item) { + return new JetDefaultNamedDeclarationPresentation(item); + } +} diff --git a/idea/testData/navigation/implementations/ConstructorPropertyOverriddenNavigation.kt b/idea/testData/navigation/implementations/ConstructorPropertyOverriddenNavigation.kt new file mode 100644 index 00000000000..a7b04f331b2 --- /dev/null +++ b/idea/testData/navigation/implementations/ConstructorPropertyOverriddenNavigation.kt @@ -0,0 +1,12 @@ +package testing + +open class Test(open var some: Int) + +class OtherTestInConstructor(override var some: Int): Test(some) + +class OtherTestInBody(some: Int, other: String): Test(some) { + override var some: Int = some +} + +// REF: (testing.OtherTestInConstructor).some +// REF: (testing.OtherTestInBody).some \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java index 27e2f18ef46..dd81a32003a 100644 --- a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoImplementationTest.java @@ -41,6 +41,10 @@ public class JetGotoImplementationTest extends LightCodeInsightTestCase { doTest(); } + public void testConstructorPropertyOverriddenNavigation() { + doTest(); + } + @NotNull @Override protected String getTestDataPath() { From 9bb2d90bcaf13101a7833616b6f8042cbdc7a976 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 6 May 2013 15:58:14 +0400 Subject: [PATCH 09/92] Go to implementation line markers for properties --- .../jetbrains/jet/plugin/JetBundle.properties | 8 + .../highlighter/JetLineMarkerProvider.java | 226 ++++++++++++++---- .../search/KotlinDefinitionsSearcher.java | 2 +- .../lineMarker/PropertyOverride.kt | 7 + .../OverrideImplementLineMarkerTest.java | 4 + 5 files changed, 201 insertions(+), 46 deletions(-) create mode 100644 idea/testData/codeInsight/lineMarker/PropertyOverride.kt diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index 0ac4c6666ce..868da4e6b67 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -202,3 +202,11 @@ add.name.to.argument.single=Add name to argument\: ''{0}'' add.name.to.argument.multiple=Add name to argument... add.name.to.argument.action=Add name to argument... add.name.to.parameter.name.chooser.title=Choose parameter name + +property.is.implemented.too.many=Has implementations +property.is.overridden.too.many=Is overridden in subclasses +property.is.implemented.header=Is implemented in
+property.is.overridden.header=Is overridden in
+ +navigation.title.overriding.property=Choose Implementation of {0} +navigation.findUsages.title.overriding.property=Overriding properties of {0} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index 25577f783f3..667bff4566a 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -16,18 +16,20 @@ package org.jetbrains.jet.plugin.highlighter; -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.google.common.collect.Sets; +import com.google.common.collect.*; import com.intellij.codeHighlighting.Pass; import com.intellij.codeInsight.daemon.GutterIconNavigationHandler; import com.intellij.codeInsight.daemon.LineMarkerInfo; import com.intellij.codeInsight.daemon.LineMarkerProvider; +import com.intellij.codeInsight.daemon.impl.GutterIconTooltipHelper; import com.intellij.codeInsight.daemon.impl.LineMarkerNavigator; import com.intellij.codeInsight.daemon.impl.MarkerType; +import com.intellij.codeInsight.daemon.impl.PsiElementListNavigator; import com.intellij.codeInsight.hint.HintUtil; import com.intellij.codeInsight.navigation.NavigationUtil; import com.intellij.icons.AllIcons; +import com.intellij.ide.util.DefaultPsiElementCellRenderer; +import com.intellij.ide.util.PsiClassListCellRenderer; import com.intellij.openapi.editor.markup.GutterIconRenderer; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.project.DumbService; @@ -35,19 +37,17 @@ import com.intellij.openapi.ui.popup.JBPopup; import com.intellij.openapi.ui.popup.JBPopupFactory; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.CommonClassNames; -import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; +import com.intellij.psi.*; +import com.intellij.psi.search.PsiElementProcessor; +import com.intellij.psi.search.PsiElementProcessorAdapter; import com.intellij.psi.search.searches.AllOverridingMethodsSearch; import com.intellij.psi.search.searches.ClassInheritorsSearch; +import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.psi.util.PsiUtilCore; import com.intellij.ui.awt.RelativePoint; -import com.intellij.util.Function; -import com.intellij.util.NullableFunction; -import com.intellij.util.Processor; -import com.intellij.util.PsiNavigateUtil; +import com.intellij.util.*; import gnu.trove.THashSet; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.LightClassUtil; @@ -58,16 +58,15 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.codeInsight.JetFunctionPsiElementCellRenderer; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; +import org.jetbrains.jet.plugin.search.KotlinDefinitionsSearcher; import org.jetbrains.jet.renderer.DescriptorRenderer; import javax.swing.*; import java.awt.event.MouseEvent; -import java.util.Collection; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; public class JetLineMarkerProvider implements LineMarkerProvider { public static final Icon OVERRIDING_MARK = AllIcons.Gutter.OverridingMethod; @@ -115,6 +114,98 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } ); + private static final MarkerType OVERRIDDEN_PROPERTY = new MarkerType( + new NullableFunction() { + @Override + public String fun(@Nullable PsiElement element) { + if (element == null) return null; + + assert element.getParent() instanceof JetProperty : "This tooltip provider should be placed only on identifies in properties"; + JetProperty property = (JetProperty) element.getParent(); + + PsiElementProcessor.CollectElementsWithLimit processor = new PsiElementProcessor.CollectElementsWithLimit(5); + Processor consumer = new AdapterProcessor( + new CommonProcessors.UniqueProcessor(new PsiElementProcessorAdapter(processor)), + new Function() { + @Override + public PsiClass fun(PsiMethod method) { + return method.getContainingClass(); + } + }); + + for (PsiMethod method : LightClassUtil.getLightClassPropertyMethods(property)) { + if (!processor.isOverflow()) { + OverridingMethodsSearch.search(method, true).forEach(consumer); + } + } + + boolean isImplemented = isImplemented(property); + if (processor.isOverflow()) { + return isImplemented ? + JetBundle.message("property.is.implemented.too.many") : + JetBundle.message("property.is.overridden.too.many"); + } + + List collectedClasses = Lists.newArrayList(processor.getCollection()); + if (collectedClasses.isEmpty()) return null; + + Collections.sort(collectedClasses, new PsiClassListCellRenderer().getComparator()); + + String start = isImplemented ? + JetBundle.message("property.is.implemented.header") : + JetBundle.message("property.is.overridden.header"); + + @NonNls String pattern = "    {0}"; + return GutterIconTooltipHelper.composeText(collectedClasses, start, pattern); + } + }, + + new LineMarkerNavigator() { + @Override + public void browse(@Nullable MouseEvent e, @Nullable PsiElement element) { + if (element == null) return; + + assert element.getParent() instanceof JetProperty : "This marker navigator should be placed only on identifies in properties"; + JetProperty property = (JetProperty) element.getParent(); + + if (DumbService.isDumb(element.getProject())) { + DumbService.getInstance(element.getProject()).showDumbModeNotification("Navigation to overriding classes is not possible during index update"); + return; + } + + final LightClassUtil.PropertyAccessorsPsiMethods psiPropertyMethods = + LightClassUtil.getLightClassPropertyMethods((JetProperty) element.getParent()); + + final CommonProcessors.CollectUniquesProcessor elementProcessor = new CommonProcessors.CollectUniquesProcessor(); + Runnable jetPsiMethodProcessor = new Runnable() { + @Override + public void run() { + KotlinDefinitionsSearcher.processPropertyImplementationsMethods(psiPropertyMethods, elementProcessor); + } + }; + + if (!ProgressManager.getInstance().runProcessWithProgressSynchronously( + jetPsiMethodProcessor, + MarkerType.SEARCHING_FOR_OVERRIDING_METHODS, true, + element.getProject(), + e != null ? (JComponent) e.getComponent() : null)) { + return; + } + + DefaultPsiElementCellRenderer renderer = new DefaultPsiElementCellRenderer(); + List elements = Ordering.from(renderer.getComparator()).sortedCopy(elementProcessor.getResults()); + + NavigatablePsiElement[] navigatableElements = Iterables.toArray( + Iterables.filter(elements, NavigatablePsiElement.class), NavigatablePsiElement.class); + + PsiElementListNavigator.openTargets(e, navigatableElements, + JetBundle.message("navigation.title.overriding.property", property.getName()), + JetBundle.message("navigation.findUsages.title.overriding.property", property.getName()), + renderer); + } + } + ); + @Nullable private static PsiClass getPsiClass(@Nullable PsiElement element) { if (element == null) return null; @@ -274,6 +365,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } Set functions = Sets.newHashSet(); + Set properties = Sets.newHashSet(); for (PsiElement element : elements) { if (element instanceof JetClass) { @@ -283,9 +375,14 @@ public class JetLineMarkerProvider implements LineMarkerProvider { if (element instanceof JetNamedFunction) { functions.add((JetNamedFunction) element); } + + if (element instanceof JetProperty) { + properties.add((JetProperty) element); + } } collectOverridingAccessors(functions, result); + collectOverridingPropertiesAccessors(properties, result); } private static void collectInheritingClasses(JetClass element, Collection result) { @@ -334,8 +431,38 @@ public class JetLineMarkerProvider implements LineMarkerProvider { return false; } + private static void collectOverridingPropertiesAccessors(Collection properties, Collection result) { + Map mappingToJava = Maps.newHashMap(); + for (JetProperty property : properties) { + if (isOverridableHeuristic(property)) { + LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = LightClassUtil.getLightClassPropertyMethods(property); + for (PsiMethod psiMethod : accessorsPsiMethods) { + mappingToJava.put(psiMethod, property); + } + } + } + + Set classes = collectContainingClasses(mappingToJava.keySet()); + + for (JetProperty property : getOverriddenDeclarations(mappingToJava, classes)) { + ProgressManager.checkCanceled(); + + PsiElement anchor = property.getNameIdentifier(); + if (anchor == null) anchor = property; + + LineMarkerInfo info = new LineMarkerInfo( + anchor, anchor.getTextOffset(), + isImplemented(property) ? IMPLEMENTED_MARK : OVERRIDDEN_MARK, + Pass.UPDATE_OVERRIDEN_MARKERS, + OVERRIDDEN_PROPERTY.getTooltip(), OVERRIDDEN_PROPERTY.getNavigationHandler(), + GutterIconRenderer.Alignment.RIGHT); + + result.add(info); + } + } + private static void collectOverridingAccessors(Collection functions, Collection result) { - final Map mappingToJava = Maps.newHashMap(); + Map mappingToJava = Maps.newHashMap(); for (JetNamedFunction function : functions) { if (isOverridableHeuristic(function)) { PsiMethod method = LightClassUtil.getLightClassMethod(function); @@ -345,36 +472,9 @@ public class JetLineMarkerProvider implements LineMarkerProvider { } } - Set classes = new THashSet(); - for (PsiMethod method : mappingToJava.keySet()) { - ProgressManager.checkCanceled(); - PsiClass parentClass = method.getContainingClass(); - if (parentClass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(parentClass.getQualifiedName())) { - classes.add(parentClass); - } - } + Set classes = collectContainingClasses(mappingToJava.keySet()); - final Set overridden = Sets.newHashSet(); - for (PsiClass aClass : classes) { - AllOverridingMethodsSearch.search(aClass).forEach(new Processor>() { - @Override - public boolean process(Pair pair) { - ProgressManager.checkCanceled(); - - PsiMethod superMethod = pair.getFirst(); - - JetNamedFunction function = mappingToJava.get(superMethod); - if (function != null) { - mappingToJava.remove(superMethod); - overridden.add(function); - } - - return !mappingToJava.isEmpty(); - } - }); - } - - for (JetNamedFunction function : overridden) { + for (JetNamedFunction function : getOverriddenDeclarations(mappingToJava, classes)) { ProgressManager.checkCanceled(); PsiElement anchor = function.getNameIdentifier(); @@ -390,4 +490,40 @@ public class JetLineMarkerProvider implements LineMarkerProvider { result.add(info); } } + + private static Set collectContainingClasses(Collection methods) { + Set classes = new THashSet(); + for (PsiMethod method : methods) { + ProgressManager.checkCanceled(); + PsiClass parentClass = method.getContainingClass(); + if (parentClass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(parentClass.getQualifiedName())) { + classes.add(parentClass); + } + } + return classes; + } + + private static Set getOverriddenDeclarations(final Map mappingToJava, Set classes) { + final Set overridden = Sets.newHashSet(); + for (PsiClass aClass : classes) { + AllOverridingMethodsSearch.search(aClass).forEach(new Processor>() { + @Override + public boolean process(Pair pair) { + ProgressManager.checkCanceled(); + + PsiMethod superMethod = pair.getFirst(); + + T declaration = mappingToJava.get(superMethod); + if (declaration != null) { + mappingToJava.remove(superMethod); + overridden.add(declaration); + } + + return !mappingToJava.isEmpty(); + } + }); + } + + return overridden; + } } diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index 89980b7611d..bbceb76d7ca 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -103,7 +103,7 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase consumer) { + public static void processPropertyImplementationsMethods(LightClassUtil.PropertyAccessorsPsiMethods accessors, @NotNull Processor consumer) { for (PsiMethod method : accessors) { PsiMethod[] implementations = MethodImplementationsSearch.getMethodImplementations(method); for (PsiMethod implementation : implementations) { diff --git a/idea/testData/codeInsight/lineMarker/PropertyOverride.kt b/idea/testData/codeInsight/lineMarker/PropertyOverride.kt new file mode 100644 index 00000000000..1c3507c2823 --- /dev/null +++ b/idea/testData/codeInsight/lineMarker/PropertyOverride.kt @@ -0,0 +1,7 @@ +open class Base { + open var writable: Int = 12 +} + +class SubBase: Base() { + override var writable: Int = 42 +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java index 1d5c0fe2bde..0e7db67e78d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java @@ -46,6 +46,10 @@ public class OverrideImplementLineMarkerTest extends LightCodeInsightFixtureTest doTest(); } + public void testPropertyOverride() throws Throwable { + doTest(); + } + private void doTest() { try { myFixture.configureByFile(getTestName(false) + ".kt"); From 11a10673803fd9c09549bca91b8f78b3d4727420 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 14 May 2013 17:12:58 +0400 Subject: [PATCH 10/92] Workaround assert when java function overrides kotlin property accessor #KT-3621 Open --- .../java/kotlinSignature/SignaturesPropagationData.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java index 264c5c67d69..62b5993f9f3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java @@ -242,9 +242,10 @@ public class SignaturesPropagationData { continue; } - assert superFun instanceof FunctionDescriptor : superFun.getClass().getName(); - - superFunctions.add(substituteSuperFunction(superclassToSupertype, (FunctionDescriptor) superFun)); + // TODO: Add propagation for other kotlin descriptors (KT-3621) + if (superFun instanceof FunctionDescriptor) { + superFunctions.add(substituteSuperFunction(superclassToSupertype, (FunctionDescriptor) superFun)); + } } // sorting for diagnostic stability From 3a2a932e2f395064ca858f2d42c578368e74db67 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 18:44:58 +0400 Subject: [PATCH 11/92] Add utility method for getting class from constructor parameter --- .../org/jetbrains/jet/lang/psi/JetPsiUtil.java | 17 +++++++++++++++-- .../jetbrains/jet/asJava/LightClassUtil.java | 7 +++++-- .../jetbrains/jet/plugin/JetIconProvider.java | 8 +++----- .../search/KotlinDefinitionsSearcher.java | 2 +- 4 files changed, 24 insertions(+), 10 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 3228d0f9e32..d54ddbe6179 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -197,8 +197,9 @@ public class JetPsiUtil { firstPart = getFQName((JetNamedDeclaration) parent); } else if (namedDeclaration instanceof JetParameter) { - if (((JetParameter) namedDeclaration).getValOrVarNode() != null && parent != null && parent.getParent() instanceof JetClassOrObject) { - firstPart = getFQName((JetClassOrObject) parent.getParent()); + JetClass constructorClass = getClassIfParameterIsProperty((JetParameter) namedDeclaration); + if (constructorClass != null) { + firstPart = getFQName(constructorClass); } } else if (parent instanceof JetObjectDeclaration) { @@ -574,6 +575,18 @@ public class JetPsiUtil { } } + @Nullable + public static JetClass getClassIfParameterIsProperty(@NotNull JetParameter jetParameter) { + if (jetParameter.getValOrVarNode() != null) { + PsiElement parent = jetParameter.getParent(); + if (parent instanceof JetParameterList && parent.getParent() instanceof JetClass) { + return (JetClass) parent.getParent(); + } + } + + return null; + } + @Nullable private static IElementType getOperation(@NotNull JetExpression expression) { if (expression instanceof JetQualifiedExpression) { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java index 7ef41f7d4c3..6fd300653e8 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java @@ -196,8 +196,11 @@ public class LightClassUtil { @Nullable private static PsiClass getWrappingClass(@NotNull JetDeclaration declaration) { - if (declaration instanceof JetParameter && declaration.getParent().getParent() instanceof JetClass) { - return getPsiClass((JetClassOrObject) declaration.getParent().getParent()); + if (declaration instanceof JetParameter) { + JetClass constructorClass = JetPsiUtil.getClassIfParameterIsProperty((JetParameter) declaration); + if (constructorClass != null) { + return getPsiClass(constructorClass); + } } if (declaration instanceof JetPropertyAccessor) { diff --git a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java index 4b5efb62853..a1268443475 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java @@ -143,12 +143,10 @@ public class JetIconProvider extends IconProvider { } if (psiElement instanceof JetParameter) { JetParameter parameter = (JetParameter) psiElement; - if (parameter.getValOrVarNode() != null) { - JetParameterList parameterList = PsiTreeUtil.getParentOfType(psiElement, JetParameterList.class); - if (parameterList != null && parameterList.getParent() instanceof JetClass) { - return parameter.isMutable() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL; - } + if (JetPsiUtil.getClassIfParameterIsProperty(parameter) != null) { + return parameter.isMutable() ? JetIcons.FIELD_VAR : JetIcons.FIELD_VAL; } + return JetIcons.PARAMETER; } if (psiElement instanceof JetProperty) { diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index bbceb76d7ca..534be277f50 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -48,7 +48,7 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase Date: Mon, 20 May 2013 13:23:46 +0400 Subject: [PATCH 12/92] Using JetClsMethod interface to recognize method compiled from kotlin --- .../src/org/jetbrains/jet/asJava/LightClassUtil.java | 11 ++++------- .../jet/plugin/search/KotlinDefinitionsSearcher.java | 4 ++-- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java index 6fd300653e8..374a13bb3e5 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassUtil.java @@ -23,7 +23,6 @@ import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiCompiledElement; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.impl.java.stubs.PsiClassStub; @@ -161,12 +160,10 @@ public class LightClassUtil { List methods = new SmartList(); for (PsiMethod method : psiClass.getMethods()) { try { - if (method instanceof JetClsMethod) { - if (method instanceof PsiCompiledElement && ((PsiCompiledElement) method).getMirror() == declaration) { - methods.add(method); - if (!collectAll) { - return methods; - } + if (method instanceof JetClsMethod && ((JetClsMethod) method).getOrigin() == declaration) { + methods.add(method); + if (!collectAll) { + return methods; } } } diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java index 534be277f50..6d0cdb48c18 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java @@ -21,7 +21,6 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.QueryExecutorBase; import com.intellij.openapi.util.Computable; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiCompiledElement; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.search.searches.ClassInheritorsSearch; @@ -30,6 +29,7 @@ import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.java.JetClsMethod; public class KotlinDefinitionsSearcher extends QueryExecutorBase { @Override @@ -107,7 +107,7 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase Date: Mon, 20 May 2013 17:02:38 +0400 Subject: [PATCH 13/92] KT-3575, KT-2297 Inserting pair for "${": use JetPairMatcher instead of KotlinTypeHandler #KT-3575 fixed --- .../org/jetbrains/jet/plugin/JetPairMatcher.java | 3 ++- .../jet/plugin/editor/KotlinTypedHandler.java | 14 -------------- .../org/jetbrains/jet/editor/TypedHandlerTest.java | 6 ++++++ 3 files changed, 8 insertions(+), 15 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java index 5646c25cac2..a97fdee0200 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java @@ -39,7 +39,8 @@ public class JetPairMatcher implements PairedBraceMatcher { @Override public boolean isPairedBracesAllowedBeforeType(@NotNull IElementType lbraceType, @Nullable IElementType contextType) { - return JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType) + return lbraceType.equals(JetTokens.LONG_TEMPLATE_ENTRY_START) + || JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType) || contextType == JetTokens.SEMICOLON || contextType == JetTokens.COMMA || contextType == JetTokens.RPAR diff --git a/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java b/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java index baedb696788..b35d929710d 100644 --- a/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java @@ -57,20 +57,6 @@ public class KotlinTypedHandler extends TypedHandlerDelegate { JetLtGtTypingUtils.handleJetAutoCloseLT(editor); return Result.STOP; } - - if (!(file instanceof JetFile) || !CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET) { - return Result.CONTINUE; - } - if (c == '{') { - PsiDocumentManager.getInstance(project).commitAllDocuments(); - int offset = editor.getCaretModel().getOffset(); - PsiElement previousElement = file.findElementAt(offset - 1); - if (previousElement instanceof LeafPsiElement - && ((LeafPsiElement) previousElement).getElementType() == JetTokens.LONG_TEMPLATE_ENTRY_START) { - editor.getDocument().insertString(offset, "}"); - } - return Result.STOP; - } return Result.CONTINUE; } } diff --git a/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java b/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java index 78a78adffbf..5ac75e43c72 100644 --- a/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java +++ b/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java @@ -26,6 +26,12 @@ public class TypedHandlerTest extends LightCodeInsightTestCase { checkResultByText("val x = \"${}\""); } + public void testKT3575() throws Exception { + configureFromFileText("a.kt", "val x = \"$]\""); + EditorTestUtil.performTypingAction(getEditor(), '{'); + checkResultByText("val x = \"${}]\""); + } + public void testTypeLtInFunDeclaration() throws Exception { doLtGtTest("fun "); } From e98ee752bf4dae5e780d12e42c5562c1130b8825 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 16:03:03 +0400 Subject: [PATCH 14/92] Base class for jet light fixture to execute runPostStartupActivities() in more fixture tests --- .../JetLightCodeInsightFixtureTestCase.java | 38 +++++++++++++++++ .../OverrideImplementLineMarkerTest.java | 7 ++-- .../plugin/javaFacade/JetJavaFacadeTest.java | 27 ++++++++---- .../plugin/navigation/JetGotoSymbolTest.java | 41 ++++--------------- 4 files changed, 67 insertions(+), 46 deletions(-) create mode 100644 idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java diff --git a/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java new file mode 100644 index 00000000000..0bd5ce32473 --- /dev/null +++ b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin; + +import com.intellij.ide.startup.impl.StartupManagerImpl; +import com.intellij.openapi.startup.StartupManager; +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; + +public abstract class JetLightCodeInsightFixtureTestCase extends LightCodeInsightFixtureTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities(); + } + + @Override + protected void tearDown() throws Exception { + super.tearDown(); + } + + protected String fileName() { + return getTestName(false) + ".kt"; + } +} diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java index 0e7db67e78d..c81b6d7ca84 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementLineMarkerTest.java @@ -22,13 +22,12 @@ import com.intellij.openapi.editor.Document; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiDocumentManager; import com.intellij.testFramework.ExpectedHighlightingData; -import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.PluginTestCaseBase; import java.util.List; -public class OverrideImplementLineMarkerTest extends LightCodeInsightFixtureTestCase { - +public class OverrideImplementLineMarkerTest extends JetLightCodeInsightFixtureTestCase { @Override protected String getBasePath() { return PluginTestCaseBase.TEST_DATA_PROJECT_RELATIVE + "/codeInsight/lineMarker"; @@ -52,7 +51,7 @@ public class OverrideImplementLineMarkerTest extends LightCodeInsightFixtureTest private void doTest() { try { - myFixture.configureByFile(getTestName(false) + ".kt"); + myFixture.configureByFile(fileName()); Project project = myFixture.getProject(); Document document = myFixture.getEditor().getDocument(); diff --git a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java index a43fd97d429..a49ce9969dc 100644 --- a/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/javaFacade/JetJavaFacadeTest.java @@ -20,16 +20,16 @@ import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.testFramework.LightProjectDescriptor; -import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.asJava.LightClassUtil; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.JetLightProjectDescriptor; import org.jetbrains.jet.plugin.PluginTestCaseBase; -public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { +public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase { @NotNull @Override protected LightProjectDescriptor getProjectDescriptor() { @@ -39,7 +39,11 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { @Override public void setUp() throws Exception { super.setUp(); - myFixture.setTestDataPath(PluginTestCaseBase.getTestDataPathBase() + "/javaFacade"); + } + + @Override + protected String getTestDataPath() { + return PluginTestCaseBase.getTestDataPathBase() + "/javaFacade"; } public void testDoNotWrapFunFromLocalClass() { @@ -135,7 +139,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } public void testEa38770() { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); PsiReference reference = myFixture.getFile().findReferenceAt(myFixture.getCaretOffset()); assertNotNull(reference); @@ -148,7 +152,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } public void testInnerClass() throws Exception { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); JavaPsiFacade facade = myFixture.getJavaFacade(); PsiClass mirrorClass = facade.findClass("foo.Outer.Inner", GlobalSearchScope.allScope(getProject())); @@ -160,7 +164,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } public void testClassObject() throws Exception { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); JavaPsiFacade facade = myFixture.getJavaFacade(); PsiClass theClass = facade.findClass("foo.TheClass", GlobalSearchScope.allScope(getProject())); @@ -188,7 +192,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } public void testLightClassIsNotCreatedForBuiltins() throws Exception { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); PsiReference reference = myFixture.getFile().findReferenceAt(myFixture.getCaretOffset()); assert reference != null; @@ -242,7 +246,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { @NotNull private T getPreparedElement(Class elementClass) { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); int offset = myFixture.getEditor().getCaretModel().getOffset(); PsiElement elementAt = myFixture.getFile().findElementAt(offset); @@ -270,7 +274,7 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { } private void doTestWrapClass() { - myFixture.configureByFile(getTestName(true) + ".kt"); + myFixture.configureByFile(fileName()); int offset = myFixture.getEditor().getCaretModel().getOffset(); PsiElement elementAt = myFixture.getFile().findElementAt(offset); @@ -289,4 +293,9 @@ public class JetJavaFacadeTest extends LightCodeInsightFixtureTestCase { // No exception/error should happen here lightClass.getDelegate(); } + + @Override + protected String fileName() { + return getTestName(true) + ".kt"; + } } diff --git a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoSymbolTest.java b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoSymbolTest.java index e956bb575ee..f754eb0ea05 100644 --- a/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoSymbolTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/navigation/JetGotoSymbolTest.java @@ -16,40 +16,12 @@ package org.jetbrains.jet.plugin.navigation; -import com.intellij.openapi.module.Module; -import com.intellij.openapi.module.ModuleType; -import com.intellij.openapi.module.StdModuleTypes; -import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.roots.ContentEntry; -import com.intellij.openapi.roots.ModifiableRootModel; -import com.intellij.testFramework.LightProjectDescriptor; -import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; -import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.PluginTestCaseBase; import java.io.File; -public class JetGotoSymbolTest extends LightCodeInsightFixtureTestCase { - @NotNull - @Override - protected LightProjectDescriptor getProjectDescriptor() { - return new LightProjectDescriptor() { - @Override - public ModuleType getModuleType() { - return StdModuleTypes.JAVA; - } - - @Override - public Sdk getSdk() { - return PluginTestCaseBase.jdkFromIdeaHome(); - } - - @Override - public void configureModule(Module module, ModifiableRootModel model, ContentEntry contentEntry) { - } - }; - } - +public class JetGotoSymbolTest extends JetLightCodeInsightFixtureTestCase { public void testProperties() { doTest(); } @@ -64,9 +36,12 @@ public class JetGotoSymbolTest extends LightCodeInsightFixtureTestCase { } protected void doTest() { - String fileName = getTestName(true) + ".kt"; - myFixture.configureByFile(fileName); - + myFixture.configureByFile(fileName()); NavigationTestUtils.assertGotoSymbol(getProject(), myFixture.getEditor()); } + + @Override + protected String fileName() { + return getTestName(true) + ".kt"; + } } From f33792a567c59e36fbb62407c26a868c0f522d3b Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 20 May 2013 16:28:04 +0400 Subject: [PATCH 15/92] Configure project descriptor with directives Implement optimize import test with redesigned class --- .../jetbrains/jet/InTextDirectivesUtils.java | 4 ++ .../editor/optimizeImports/UnusedImports.kt | 4 +- .../optimizeImports/UnusedImports_after.kt | 4 +- .../JetLightCodeInsightFixtureTestCase.java | 26 +++++++++- .../importOptimizer/OptimizeImportsTest.java | 49 +++---------------- 5 files changed, 41 insertions(+), 46 deletions(-) diff --git a/compiler/tests/org/jetbrains/jet/InTextDirectivesUtils.java b/compiler/tests/org/jetbrains/jet/InTextDirectivesUtils.java index d91eb0cec1e..714bb8004ef 100644 --- a/compiler/tests/org/jetbrains/jet/InTextDirectivesUtils.java +++ b/compiler/tests/org/jetbrains/jet/InTextDirectivesUtils.java @@ -64,6 +64,10 @@ public final class InTextDirectivesUtils { return result; } + public static boolean isDirectiveDefined(String fileText, String directive) { + return !findListWithPrefixes(fileText, directive).isEmpty(); + } + @Nullable public static String findStringWithPrefixes(String fileText, String... prefixes) { List strings = findListWithPrefixes(fileText, prefixes); diff --git a/idea/testData/editor/optimizeImports/UnusedImports.kt b/idea/testData/editor/optimizeImports/UnusedImports.kt index 349e61ee9f2..a454695a3fa 100644 --- a/idea/testData/editor/optimizeImports/UnusedImports.kt +++ b/idea/testData/editor/optimizeImports/UnusedImports.kt @@ -17,4 +17,6 @@ class Action { measureTimeMillis({ println(HashMap().size()) }) val test : ArrayList? = null } -} \ No newline at end of file +} + +// RUNTIME \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/UnusedImports_after.kt b/idea/testData/editor/optimizeImports/UnusedImports_after.kt index fe7a544c7e8..a5377f45aa7 100644 --- a/idea/testData/editor/optimizeImports/UnusedImports_after.kt +++ b/idea/testData/editor/optimizeImports/UnusedImports_after.kt @@ -11,4 +11,6 @@ class Action { measureTimeMillis({ println(HashMap().size()) }) val test : ArrayList? = null } -} \ No newline at end of file +} + +// RUNTIME \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java index 0bd5ce32473..985f7d91651 100644 --- a/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java +++ b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java @@ -18,21 +18,43 @@ package org.jetbrains.jet.plugin; import com.intellij.ide.startup.impl.StartupManagerImpl; import com.intellij.openapi.startup.StartupManager; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.InTextDirectivesUtils; + +import java.io.File; public abstract class JetLightCodeInsightFixtureTestCase extends LightCodeInsightFixtureTestCase { + LightProjectDescriptor projectDescriptor = null; + @Override protected void setUp() throws Exception { + String fileText = FileUtil.loadFile(new File(getTestDataPath(), fileName())); + if (InTextDirectivesUtils.isDirectiveDefined(fileText, "RUNTIME")) { + projectDescriptor = JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE; + } + else { + projectDescriptor = JetLightProjectDescriptor.INSTANCE; + } + super.setUp(); + ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities(); } @Override protected void tearDown() throws Exception { super.tearDown(); + projectDescriptor = null; } - protected String fileName() { - return getTestName(false) + ".kt"; + @NotNull + @Override + protected LightProjectDescriptor getProjectDescriptor() { + return projectDescriptor; } + + protected abstract String fileName(); } diff --git a/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java b/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java index 3ee8ca7396e..b422671bc34 100644 --- a/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java @@ -16,27 +16,15 @@ package org.jetbrains.jet.plugin.importOptimizer; -import com.intellij.ide.startup.impl.StartupManagerImpl; import com.intellij.openapi.command.CommandProcessor; import com.intellij.openapi.command.UndoConfirmationPolicy; -import com.intellij.openapi.projectRoots.JavaSdk; -import com.intellij.openapi.projectRoots.Sdk; -import com.intellij.openapi.startup.StartupManager; -import com.intellij.testFramework.LightCodeInsightTestCase; -import org.apache.commons.lang.SystemUtils; +import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.PluginTestCaseBase; import org.jetbrains.jet.plugin.editor.importOptimizer.JetImportOptimizer; -import org.jetbrains.jet.testing.ConfigLibraryUtil; import java.io.File; -public class OptimizeImportsTest extends LightCodeInsightTestCase { - @Override - protected void setUp() throws Exception { - super.setUp(); - ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities(); - } - +public class OptimizeImportsTest extends JetLightCodeInsightFixtureTestCase { public void testAlreadyOptimized() throws Exception { doTest(); } @@ -54,7 +42,7 @@ public class OptimizeImportsTest extends LightCodeInsightTestCase { } public void testUnusedImports() throws Exception { - doTestWithKotlinRuntime(); + doTest(); } public void testWithAliases() throws Exception { @@ -86,23 +74,9 @@ public class OptimizeImportsTest extends LightCodeInsightTestCase { } public void doTest() throws Exception { - configureByFile(fileName()); + myFixture.configureByFile(fileName()); invokeFormatFile(); - checkResultByFile(null, checkFileName(), true); - } - - public void doTestWithKotlinRuntime() { - try { - ConfigLibraryUtil.configureKotlinRuntime(getModule(), getFullJavaJDK()); - - configureByFile(fileName()); - invokeFormatFile(); - - checkResultByFile(null, checkFileName(), false); - } - finally { - ConfigLibraryUtil.unConfigureKotlinRuntime(getModule(), getProjectJDK()); - } + myFixture.checkResultByFile(checkFileName(), false); } @Override @@ -112,14 +86,6 @@ public class OptimizeImportsTest extends LightCodeInsightTestCase { } @Override - protected Sdk getProjectJDK() { - return PluginTestCaseBase.jdkFromIdeaHome(); - } - - protected static Sdk getFullJavaJDK() { - return JavaSdk.getInstance().createJdk("JDK", SystemUtils.getJavaHome().getAbsolutePath()); - } - public String fileName() { return getTestName(false) + ".kt"; } @@ -128,9 +94,8 @@ public class OptimizeImportsTest extends LightCodeInsightTestCase { return getTestName(false) + "_after.kt"; } - private static void invokeFormatFile() { - CommandProcessor.getInstance().executeCommand( - getProject(), new JetImportOptimizer().processFile(getFile()), + private void invokeFormatFile() { + CommandProcessor.getInstance().executeCommand(myFixture.getProject(), new JetImportOptimizer().processFile(myFixture.getFile()), "Optimize Imports", null, UndoConfirmationPolicy.DO_NOT_REQUEST_CONFIRMATION); } } From ddb7b54eee4a43c3f033e2ebade06d366ce4d3f6 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 14:03:17 +0400 Subject: [PATCH 16/92] KT-3620 Don't auto-import js.* and remove in `optimize imports` KT-3620 Fixed --- .../jet/util/QualifiedNamesUtil.java | 10 +++++ .../plugin/quickfix/ImportInsertHelper.java | 34 +++++++-------- .../handlers/DoNotInsertDefaultJsImports.kt | 6 +++ .../DoNotInsertDefaultJsImports.kt.after | 6 +++ .../optimizeImports/DefaultJsImports.kt | 8 ++++ .../optimizeImports/DefaultJsImports_after.kt | 6 +++ .../handlers/CompletionHandlerTest.java | 42 ++++++------------- .../JetLightCodeInsightFixtureTestCase.java | 7 +++- .../importOptimizer/OptimizeImportsTest.java | 9 ++-- 9 files changed, 76 insertions(+), 52 deletions(-) create mode 100644 idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt create mode 100644 idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt.after create mode 100644 idea/testData/editor/optimizeImports/DefaultJsImports.kt create mode 100644 idea/testData/editor/optimizeImports/DefaultJsImports_after.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java index be00e670556..85384187dc5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java @@ -143,6 +143,16 @@ public final class QualifiedNamesUtil { return isImported(alreadyImported, newImport.fqnPart()); } + public static boolean isImported(@NotNull Iterable imports, @NotNull ImportPath newImport) { + for (ImportPath alreadyImported : imports) { + if (isImported(alreadyImported, newImport)) { + return true; + } + } + + return false; + } + public static boolean isValidJavaFqName(@Nullable String qualifiedName) { if (qualifiedName == null) return false; diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java index d78f4cbfca3..7f0e9c84c4a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -37,9 +37,11 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.plugin.JetPluginUtil; +import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.plugin.references.JetPsiReference; import org.jetbrains.jet.util.QualifiedNamesUtil; +import org.jetbrains.k2js.analyze.JsConfiguration; import java.util.List; @@ -145,7 +147,7 @@ public class ImportInsertHelper { /** * Check that import is useless. */ - private static boolean isImportedByDefault(@NotNull ImportPath importPath, @NotNull FqName filePackageFqn) { + private static boolean isImportedByDefault(@NotNull ImportPath importPath, @NotNull JetFile jetFile) { if (importPath.fqnPart().isRoot()) { return true; } @@ -157,33 +159,31 @@ public class ImportInsertHelper { } // There's no need to import a declaration from the package of current file - if (filePackageFqn.equals(importPath.fqnPart().parent())) { + if (JetPsiUtil.getFQName(jetFile).equals(importPath.fqnPart().parent())) { return true; } } if (isImportedWithKotlinDefault(importPath)) return true; - if (isImportedWithJavaDefault(importPath)) return true; - return false; + if (KotlinFrameworkDetector.isJsKotlinModule(jetFile)) { + return isImportedWithJsDefault(importPath); + } + else { + return isImportedWithJavaDefault(importPath); + } } public static boolean isImportedWithJavaDefault(ImportPath importPath) { - for (ImportPath defaultJavaImport : JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS) { - if (QualifiedNamesUtil.isImported(defaultJavaImport, importPath)) { - return true; - } - } - return false; + return QualifiedNamesUtil.isImported(JavaBridgeConfiguration.DEFAULT_JAVA_IMPORTS, importPath); + } + + public static boolean isImportedWithJsDefault(ImportPath importPath) { + return QualifiedNamesUtil.isImported(JsConfiguration.DEFAULT_IMPORT_PATHS, importPath); } public static boolean isImportedWithKotlinDefault(ImportPath importPath) { - for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) { - if (QualifiedNamesUtil.isImported(defaultJetImport, importPath)) { - return true; - } - } - return false; + return QualifiedNamesUtil.isImported(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS, importPath); } public static boolean doNeedImport(@NotNull ImportPath importPath, @NotNull JetFile file) { @@ -196,7 +196,7 @@ public class ImportInsertHelper { importPath = new ImportPath(withoutJavaRoot, importPath.isAllUnder(), importPath.getAlias()); } - if (isImportedByDefault(importPath, JetPsiUtil.getFQName(file))) { + if (isImportedByDefault(importPath, file)) { return false; } diff --git a/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt b/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt new file mode 100644 index 00000000000..f3346bb9f4a --- /dev/null +++ b/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt @@ -0,0 +1,6 @@ +fun main(args: Array) { + println +} + +// For KT-3620: Don't auto-import js.* and remove in `optimize imports` +// JS \ No newline at end of file diff --git a/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt.after b/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt.after new file mode 100644 index 00000000000..b0281749b13 --- /dev/null +++ b/idea/testData/completion/handlers/DoNotInsertDefaultJsImports.kt.after @@ -0,0 +1,6 @@ +fun main(args: Array) { + println() +} + +// For KT-3620: Don't auto-import js.* and remove in `optimize imports` +// JS \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/DefaultJsImports.kt b/idea/testData/editor/optimizeImports/DefaultJsImports.kt new file mode 100644 index 00000000000..a6644787327 --- /dev/null +++ b/idea/testData/editor/optimizeImports/DefaultJsImports.kt @@ -0,0 +1,8 @@ +import js.Json + +fun main(args: Array) { + val a: Json? = null +} + +// For KT-3620 Don't auto-import js.* and remove in `optimize imports` +// JS \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/DefaultJsImports_after.kt b/idea/testData/editor/optimizeImports/DefaultJsImports_after.kt new file mode 100644 index 00000000000..d522ff63a54 --- /dev/null +++ b/idea/testData/editor/optimizeImports/DefaultJsImports_after.kt @@ -0,0 +1,6 @@ +fun main(args: Array) { + val a: Json? = null +} + +// For KT-3620 Don't auto-import js.* and remove in `optimize imports` +// JS \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/completion/handlers/CompletionHandlerTest.java b/idea/tests/org/jetbrains/jet/completion/handlers/CompletionHandlerTest.java index 89b59e22f95..eb35e457f24 100644 --- a/idea/tests/org/jetbrains/jet/completion/handlers/CompletionHandlerTest.java +++ b/idea/tests/org/jetbrains/jet/completion/handlers/CompletionHandlerTest.java @@ -22,35 +22,19 @@ import com.intellij.codeInsight.lookup.LookupElementPresentation; import com.intellij.codeInsight.lookup.LookupEvent; import com.intellij.codeInsight.lookup.LookupManager; import com.intellij.codeInsight.lookup.impl.LookupImpl; -import com.intellij.ide.startup.impl.StartupManagerImpl; import com.intellij.openapi.command.WriteCommandAction; -import com.intellij.openapi.startup.StartupManager; import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CodeStyleSettingsManager; -import com.intellij.testFramework.LightProjectDescriptor; -import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import junit.framework.Assert; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.plugin.JetLightProjectDescriptor; +import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase; import org.jetbrains.jet.plugin.PluginTestCaseBase; import org.jetbrains.jet.plugin.formatter.JetCodeStyleSettings; import java.io.File; -public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { - @Override - protected void setUp() throws Exception { - super.setUp(); - ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities(); - } - - @NotNull - @Override - protected LightProjectDescriptor getProjectDescriptor() { - return JetLightProjectDescriptor.INSTANCE; - } - +public class CompletionHandlerTest extends JetLightCodeInsightFixtureTestCase { public void testClassCompletionImport() { doTest(CompletionType.BASIC, 2, "SortedSet", null, '\n'); } @@ -59,6 +43,10 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { doTest(); } + public void testDoNotInsertDefaultJsImports() { + doTest(); + } + public void testDoNotInsertImportIfResolvedIntoJavaConstructor() { doTest(); } @@ -88,9 +76,9 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { } public void testSingleBrackets() { - myFixture.configureByFile(getBeforeFileName()); + myFixture.configureByFile(fileName()); myFixture.type('('); - myFixture.checkResultByFile(getAfterFileName()); + myFixture.checkResultByFile(afterFileName()); } public void testExistingSingleBrackets() { @@ -106,9 +94,9 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { } public void testInsertFunctionWithBothParentheses() { - myFixture.configureByFile(getBeforeFileName()); + myFixture.configureByFile(fileName()); myFixture.type("test()"); - myFixture.checkResultByFile(getAfterFileName()); + myFixture.checkResultByFile(afterFileName()); } public void testInsertImportOnTab() { @@ -144,7 +132,7 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { } public void doTest(CompletionType type, int time, @Nullable String lookupString, @Nullable String tailText, char completionChar) { - myFixture.configureByFile(getBeforeFileName()); + myFixture.configureByFile(fileName()); if (lookupString != null || tailText != null) { myFixture.complete(type, time); @@ -158,7 +146,7 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { forceCompleteFirst(type, time); } - myFixture.checkResultByFile(getAfterFileName()); + myFixture.checkResultByFile(afterFileName()); } @Nullable @@ -203,11 +191,7 @@ public class CompletionHandlerTest extends LightCodeInsightFixtureTestCase { return foundElement; } - protected String getBeforeFileName() { - return getTestName(false) + ".kt"; - } - - protected String getAfterFileName() { + protected String afterFileName() { return getTestName(false) + ".kt.after"; } diff --git a/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java index 985f7d91651..ae4309512ae 100644 --- a/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java +++ b/idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java @@ -35,6 +35,9 @@ public abstract class JetLightCodeInsightFixtureTestCase extends LightCodeInsigh if (InTextDirectivesUtils.isDirectiveDefined(fileText, "RUNTIME")) { projectDescriptor = JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE; } + else if (InTextDirectivesUtils.isDirectiveDefined(fileText, "JS")) { + projectDescriptor = JetStdJSProjectDescriptor.INSTANCE; + } else { projectDescriptor = JetLightProjectDescriptor.INSTANCE; } @@ -56,5 +59,7 @@ public abstract class JetLightCodeInsightFixtureTestCase extends LightCodeInsigh return projectDescriptor; } - protected abstract String fileName(); + protected String fileName() { + return getTestName(false) + ".kt"; + } } diff --git a/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java b/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java index b422671bc34..a84def047b5 100644 --- a/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/importOptimizer/OptimizeImportsTest.java @@ -29,6 +29,10 @@ public class OptimizeImportsTest extends JetLightCodeInsightFixtureTestCase { doTest(); } + public void testDefaultJsImports() throws Exception { + doTest(); + } + public void testRemoveImportsIfGeneral() throws Exception { doTest(); } @@ -85,11 +89,6 @@ public class OptimizeImportsTest extends JetLightCodeInsightFixtureTestCase { File.separator; } - @Override - public String fileName() { - return getTestName(false) + ".kt"; - } - public String checkFileName() { return getTestName(false) + "_after.kt"; } From 5ca4df3d1d78924d3ee9d005559ce11246957b26 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 15:27:09 +0400 Subject: [PATCH 17/92] KT-3618 Missing space in error message "inconstructor" #KT-3618 Fixed --- .../org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java | 2 +- idea/testData/diagnosticMessage/conflictingSubstitutions1.html | 2 +- idea/testData/diagnosticMessage/conflictingSubstitutions2.html | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java index fd0ba9018a0..42bc78af206 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java @@ -184,7 +184,7 @@ public class Renderers { result.text(newText() .normal("Cannot infer type parameter ") .strong(firstConflictingParameter.getName()) - .normal(" in")); + .normal(" in ")); //String type = strong(firstConflictingParameter.getName()); TableRenderer table = newTable(); result.table(table); diff --git a/idea/testData/diagnosticMessage/conflictingSubstitutions1.html b/idea/testData/diagnosticMessage/conflictingSubstitutions1.html index 0e8a5072ff5..150ce8e0434 100644 --- a/idea/testData/diagnosticMessage/conflictingSubstitutions1.html +++ b/idea/testData/diagnosticMessage/conflictingSubstitutions1.html @@ -2,7 +2,7 @@ Type inference failed: Cannot infer type parameter T - in + in
diff --git a/idea/testData/diagnosticMessage/conflictingSubstitutions2.html b/idea/testData/diagnosticMessage/conflictingSubstitutions2.html index 61c7f6a3491..08c46d628b7 100644 --- a/idea/testData/diagnosticMessage/conflictingSubstitutions2.html +++ b/idea/testData/diagnosticMessage/conflictingSubstitutions2.html @@ -2,7 +2,7 @@ Type inference failed: Cannot infer type parameter T - in
+ in
From 1bf06f7c02e7dc7bc68824926bd7f4174b780986 Mon Sep 17 00:00:00 2001 From: chocolateboy Date: Wed, 8 May 2013 05:10:19 +0100 Subject: [PATCH 18/92] make the preloader's required profiler argument (time|notime) an optional switch: -pp fixes for broken Windows batch files --- compiler/cli/bin/kotlinc-js | 9 +++++++-- compiler/cli/bin/kotlinc-js.bat | 26 ++++++++++++++++++++++---- compiler/cli/bin/kotlinc-jvm | 9 +++++++-- compiler/cli/bin/kotlinc-jvm.bat | 26 ++++++++++++++++++++++---- 4 files changed, 58 insertions(+), 12 deletions(-) diff --git a/compiler/cli/bin/kotlinc-js b/compiler/cli/bin/kotlinc-js index cc2129bf160..9a73260e964 100755 --- a/compiler/cli/bin/kotlinc-js +++ b/compiler/cli/bin/kotlinc-js @@ -2,7 +2,7 @@ # ############################################################################## # Copyright 2002-2011, LAMP/EPFL -# Copyright 2011, JetBrains +# Copyright 2011-2013, JetBrains # # This is free software; see the distribution for copying conditions. # There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A @@ -45,6 +45,7 @@ fi # -D options will be available as system properties. declare -a java_args declare -a kotlin_args +profile_preloader="notime" while [ $# -gt 0 ]; do case "$1" in @@ -62,6 +63,10 @@ while [ $# -gt 0 ]; do kotlin_args=("${kotlin_args[@]}" "$1") shift ;; + -pp) + profile_preloader="time" + shift + ;; *) kotlin_args=("${kotlin_args[@]}" "$1") shift @@ -82,4 +87,4 @@ CPSELECT="-cp " $JAVA_OPTS \ "${java_args[@]}" \ ${CPSELECT}"${KOTLIN_HOME}/lib/kotlin-preloader.jar" \ - org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" org.jetbrains.jet.cli.js.K2JSCompiler 4096 "$@" + org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" org.jetbrains.jet.cli.js.K2JSCompiler 4096 $profile_preloader "$@" diff --git a/compiler/cli/bin/kotlinc-js.bat b/compiler/cli/bin/kotlinc-js.bat index fef3bb6bcc2..4ef29f47720 100644 --- a/compiler/cli/bin/kotlinc-js.bat +++ b/compiler/cli/bin/kotlinc-js.bat @@ -2,13 +2,17 @@ rem based on scalac.bat from the Scala distribution rem ########################################################################## rem # Copyright 2002-2011, LAMP/EPFL -rem # Copyright 2011, JetBrains +rem # Copyright 2011-2013, JetBrains rem # rem # This is free software; see the distribution for copying conditions. rem # There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A rem # PARTICULAR PURPOSE. rem ########################################################################## +rem We adopt the following conventions: +rem - System/user environment variables start with a letter +rem - Local batch variables start with an underscore ('_') + @setlocal call :set_home @@ -18,12 +22,26 @@ if not "%JAVA_HOME%"=="" ( if "%_JAVACMD%"=="" set _JAVACMD=java +set _PROFILE_PRELOADER=notime +rem re: E%1 &c., see http://www.riedquat.de/blog/2011-11-27-01#w9aab1c45 +if E%1==E-pp ( + shift + set _PROFILE_PRELOADER=time +) + rem We use the value of the JAVA_OPTS environment variable if defined set _JAVA_OPTS=-Xmx256M -Xms32M -noverify -"%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ - org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" ^ - org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 org.jetbrains.jet.cli.js.K2JSCompiler %* +rem re: %1 %2 &c., see http://www.riedquat.de/blog/2011-11-27-01#w9aab1c60 +if "%_PROFILE_PRELOADER%"=="time" ( + "%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ + org.jetbrains.jet.preloading.Preloader "%_KOTLIN_HOME%\lib\kotlin-compiler.jar" ^ + org.jetbrains.jet.cli.js.K2JSCompiler 4096 %_PROFILE_PRELOADER% %1 %2 %3 %4 %5 %6 %7 %8 %9 +) else ( + "%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ + org.jetbrains.jet.preloading.Preloader "%_KOTLIN_HOME%\lib\kotlin-compiler.jar" ^ + org.jetbrains.jet.cli.js.K2JSCompiler 4096 %_PROFILE_PRELOADER% %* +) goto end rem ########################################################################## diff --git a/compiler/cli/bin/kotlinc-jvm b/compiler/cli/bin/kotlinc-jvm index c837ecb6cb5..70b7a826def 100755 --- a/compiler/cli/bin/kotlinc-jvm +++ b/compiler/cli/bin/kotlinc-jvm @@ -2,7 +2,7 @@ # ############################################################################## # Copyright 2002-2011, LAMP/EPFL -# Copyright 2011, JetBrains +# Copyright 2011-2013, JetBrains # # This is free software; see the distribution for copying conditions. # There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A @@ -45,6 +45,7 @@ fi # -D options will be available as system properties. declare -a java_args declare -a kotlin_args +profile_preloader="notime" while [ $# -gt 0 ]; do case "$1" in @@ -62,6 +63,10 @@ while [ $# -gt 0 ]; do kotlin_args=("${kotlin_args[@]}" "$1") shift ;; + -pp) + profile_preloader="time" + shift + ;; *) kotlin_args=("${kotlin_args[@]}" "$1") shift @@ -82,4 +87,4 @@ CPSELECT="-cp " $JAVA_OPTS \ "${java_args[@]}" \ ${CPSELECT}"${KOTLIN_HOME}/lib/kotlin-preloader.jar" \ - org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 "$@" + org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 $profile_preloader "$@" diff --git a/compiler/cli/bin/kotlinc-jvm.bat b/compiler/cli/bin/kotlinc-jvm.bat index 3949f6f5797..b9a35548557 100644 --- a/compiler/cli/bin/kotlinc-jvm.bat +++ b/compiler/cli/bin/kotlinc-jvm.bat @@ -2,13 +2,17 @@ rem based on scalac.bat from the Scala distribution rem ########################################################################## rem # Copyright 2002-2011, LAMP/EPFL -rem # Copyright 2011, JetBrains +rem # Copyright 2011-2013, JetBrains rem # rem # This is free software; see the distribution for copying conditions. rem # There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A rem # PARTICULAR PURPOSE. rem ########################################################################## +rem We adopt the following conventions: +rem - System/user environment variables start with a letter +rem - Local batch variables start with an underscore ('_') + @setlocal call :set_home @@ -18,12 +22,26 @@ if not "%JAVA_HOME%"=="" ( if "%_JAVACMD%"=="" set _JAVACMD=java +set _PROFILE_PRELOADER=notime +rem re: E%1 &c., see http://www.riedquat.de/blog/2011-11-27-01#w9aab1c45 +if E%1==E-pp ( + shift + set _PROFILE_PRELOADER=time +) + rem We use the value of the JAVA_OPTS environment variable if defined set _JAVA_OPTS=-Xmx256M -Xms32M -noverify -"%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ - org.jetbrains.jet.preloading.Preloader "${KOTLIN_HOME}/lib/kotlin-compiler.jar" ^ - org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 org.jetbrains.jet.cli.jvm.K2JVMCompiler %* +rem re: %1 %2 &c., see http://www.riedquat.de/blog/2011-11-27-01#w9aab1c60 +if "%_PROFILE_PRELOADER%"=="time" ( + "%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ + org.jetbrains.jet.preloading.Preloader "%_KOTLIN_HOME%\lib\kotlin-compiler.jar" ^ + org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 %_PROFILE_PRELOADER% %1 %2 %3 %4 %5 %6 %7 %8 %9 +) else ( + "%_JAVACMD%" %_JAVA_OPTS% -cp "%_KOTLIN_HOME%\lib\kotlin-preloader.jar" ^ + org.jetbrains.jet.preloading.Preloader "%_KOTLIN_HOME%\lib\kotlin-compiler.jar" ^ + org.jetbrains.jet.cli.jvm.K2JVMCompiler 4096 %_PROFILE_PRELOADER% %* +) goto end rem ########################################################################## From a5f1a8b3f8a2ca81bd25562bb2d9e2506ffaec71 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Mon, 20 May 2013 12:13:42 +0400 Subject: [PATCH 19/92] TypeCastException when casting null to T with nullable upper-bound #KT-3637 Fixed --- .../jet/codegen/ExpressionCodegen.java | 2 +- .../boxWithStdlib/casts/asWithGeneric.kt | 21 +++++++++++++++++++ ...lackBoxWithStdlibCodegenTestGenerated.java | 16 +++++++++++++- 3 files changed, 37 insertions(+), 2 deletions(-) create mode 100644 compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 19f0dc3f072..093ac725a21 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -3513,7 +3513,7 @@ The "returned" value of try expression with no finally is either the last expres value.put(boxType(value.type), v); if (opToken != JetTokens.AS_SAFE) { - if (!rightType.isNullable()) { + if (!CodegenUtil.isNullableType(rightType)) { v.dup(); Label nonnull = new Label(); v.ifnonnull(nonnull); diff --git a/compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt b/compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt new file mode 100644 index 00000000000..aed0bdf83d2 --- /dev/null +++ b/compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt @@ -0,0 +1,21 @@ +fun test1() = null as T +fun test2(): T { + val a : Any? = null + return a as T +} + +fun test3() = null as T + +fun box(): String { + if (test1() != null) return "fail: test1" + if (test2() != null) return "fail: test2" + var result3 = "fail" + try { + test3() + } + catch(e: TypeCastException) { + result3 = "OK" + } + if (result3 != "OK") return "fail: test3" + return "OK" +} diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java index 2d014884dc9..6543439e5eb 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxWithStdlibCodegenTestGenerated.java @@ -31,12 +31,25 @@ import org.jetbrains.jet.codegen.generated.AbstractBlackBoxCodegenTest; /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/codegen/boxWithStdlib") -@InnerTestClasses({BlackBoxWithStdlibCodegenTestGenerated.DataClasses.class, BlackBoxWithStdlibCodegenTestGenerated.FullJdk.class, BlackBoxWithStdlibCodegenTestGenerated.JdkAnnotations.class, BlackBoxWithStdlibCodegenTestGenerated.Ranges.class, BlackBoxWithStdlibCodegenTestGenerated.Regressions.class, BlackBoxWithStdlibCodegenTestGenerated.Strings.class}) +@InnerTestClasses({BlackBoxWithStdlibCodegenTestGenerated.Casts.class, BlackBoxWithStdlibCodegenTestGenerated.DataClasses.class, BlackBoxWithStdlibCodegenTestGenerated.FullJdk.class, BlackBoxWithStdlibCodegenTestGenerated.JdkAnnotations.class, BlackBoxWithStdlibCodegenTestGenerated.Ranges.class, BlackBoxWithStdlibCodegenTestGenerated.Regressions.class, BlackBoxWithStdlibCodegenTestGenerated.Strings.class}) public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCodegenTest { public void testAllFilesPresentInBoxWithStdlib() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/codegen/boxWithStdlib"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("compiler/testData/codegen/boxWithStdlib/casts") + public static class Casts extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInCasts() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/codegen/boxWithStdlib/casts"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("asWithGeneric.kt") + public void testAsWithGeneric() throws Exception { + doTestWithStdlib("compiler/testData/codegen/boxWithStdlib/casts/asWithGeneric.kt"); + } + + } + @TestMetadata("compiler/testData/codegen/boxWithStdlib/dataClasses") @InnerTestClasses({DataClasses.Copy.class, DataClasses.Equals.class, DataClasses.Hashcode.class, DataClasses.Tostring.class}) public static class DataClasses extends AbstractBlackBoxCodegenTest { @@ -749,6 +762,7 @@ public class BlackBoxWithStdlibCodegenTestGenerated extends AbstractBlackBoxCode public static Test suite() { TestSuite suite = new TestSuite("BlackBoxWithStdlibCodegenTestGenerated"); suite.addTestSuite(BlackBoxWithStdlibCodegenTestGenerated.class); + suite.addTestSuite(Casts.class); suite.addTest(DataClasses.innerSuite()); suite.addTestSuite(FullJdk.class); suite.addTestSuite(JdkAnnotations.class); From 97c33b02ab322b99df2f21e1f07a405224aaa5ad Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Mon, 20 May 2013 13:10:35 +0400 Subject: [PATCH 20/92] Add library classes for delegated properties --- .../src/kotlin/properties/Properties.kt | 7 +- .../properties/delegation/Delegation.kt | 118 +++++++++ .../properties/delegation/lazy/LazyValues.kt | 75 ++++++ .../properties/delegation/DelegationTest.kt | 64 +++++ .../delegation/MapDelegationTest.kt | 224 ++++++++++++++++++ .../delegation/lazy/LazyValuesTest.kt | 143 +++++++++++ 6 files changed, 629 insertions(+), 2 deletions(-) create mode 100644 libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt create mode 100644 libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt create mode 100644 libraries/stdlib/test/properties/delegation/DelegationTest.kt create mode 100644 libraries/stdlib/test/properties/delegation/MapDelegationTest.kt create mode 100644 libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt diff --git a/libraries/stdlib/src/kotlin/properties/Properties.kt b/libraries/stdlib/src/kotlin/properties/Properties.kt index 6c5aa09312f..e045c5993c6 100644 --- a/libraries/stdlib/src/kotlin/properties/Properties.kt +++ b/libraries/stdlib/src/kotlin/properties/Properties.kt @@ -1,9 +1,8 @@ package kotlin.properties -import kotlin.* -import kotlin.util.* import java.util.HashMap import java.util.ArrayList +import kotlin.properties.delegation.ObservableProperty public class ChangeEvent(val source: Any, val name: String, val oldValue: Any?, val newValue: Any?) { var propogationId: Any? = null @@ -66,6 +65,10 @@ public abstract class ChangeSupport { } } + protected fun property(init: T): ObservableProperty { + return ObservableProperty(init) { name, oldValue, newValue -> changeProperty(name, oldValue, newValue) } + } + public fun onPropertyChange(fn: (ChangeEvent) -> Unit) { // TODO //addChangeListener(DelegateChangeListener(fn)) diff --git a/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt b/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt new file mode 100644 index 00000000000..fe4dbb05a6d --- /dev/null +++ b/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt @@ -0,0 +1,118 @@ +package kotlin.properties.delegation + +import kotlin.properties.ChangeSupport + +public class NotNullVar { + private var value: T? = null + + public fun get(thisRef: Any?, desc: PropertyMetadata): T { + return value ?: throw IllegalStateException("Property ${desc.name} should be initialized before get") + } + + public fun set(thisRef: Any?, desc: PropertyMetadata, value: T) { + this.value = value + } +} + +public class SynchronizedVar(private val initValue: T, private val lock: Any) { + private var value: T = initValue + + public fun get(thisRef: Any?, desc: PropertyMetadata): T { + return synchronized(lock) { value } + } + + public fun set(thisRef: Any?, desc: PropertyMetadata, newValue: T) { + synchronized(lock) { + value = newValue + } + } +} + +class ObservableProperty(initialValue: T, val changeSupport: (name: String, oldValue: T, newValue: T) -> Unit) { + private var value = initialValue + + public fun get(thisRef: Any?, desc: PropertyMetadata): T { + return value + } + + public fun set(thisRef: Any?, desc: PropertyMetadata, newValue: T) { + changeSupport(desc.name, value, newValue) + value = newValue + } +} + +public class KeyMissingException(message: String): RuntimeException(message) + +public abstract class MapVal { + public abstract fun getMap(thisRef: T): Map<*, *> + public abstract fun getKey(desc: PropertyMetadata): Any? + + public open fun getDefaultValue(desc: PropertyMetadata, key: Any?): V { + throw KeyMissingException("Key $key is missing") + } + + public fun get(thisRef: T, desc: PropertyMetadata): V { + val key = getKey(desc) + val map = getMap(thisRef) + if (!map.containsKey(key)) { + return getDefaultValue(desc, key) + } + return map[key] as V + } +} + +public abstract class MapVar: MapVal() { + + public fun set(thisRef: T, desc: PropertyMetadata, newValue: V) { + val map = getMap(thisRef) as MutableMap + map[getKey(desc)] = newValue + } +} + +public fun Map.readOnlyProperty(default: (() -> V)? = null): MapVal { + return object: MapVal() { + override fun getMap(thisRef: Any?) = this@readOnlyProperty + override fun getKey(desc: PropertyMetadata) = desc.name + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} + +public fun Map<*, *>.readOnlyProperty(default: (() -> V)? = null, key: Any?): MapVal { + return object: MapVal() { + override fun getMap(thisRef: Any?) = this@readOnlyProperty + override fun getKey(desc: PropertyMetadata) = key + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} + +public fun Map<*, *>.readOnlyProperty(default: (() -> V)? = null, key: (desc: PropertyMetadata) -> Any?): MapVal { + return object: MapVal() { + override fun getMap(thisRef: Any?) = this@readOnlyProperty + override fun getKey(desc: PropertyMetadata) = key(desc) + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} + +public fun MutableMap.property(default: (() -> V)? = null): MapVar { + return object: MapVar() { + override fun getMap(thisRef: Any?) = this@property + override fun getKey(desc: PropertyMetadata) = desc.name + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} + +public fun MutableMap<*, *>.property(default: (() -> V)? = null, key: Any?): MapVar { + return object: MapVar() { + override fun getMap(thisRef: Any?) = this@property + override fun getKey(desc: PropertyMetadata) = key + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} + +public fun MutableMap<*, *>.property(default: (() -> V)? = null, key: (desc: PropertyMetadata) -> Any?): MapVar { + return object: MapVar() { + override fun getMap(thisRef: Any?) = this@property + override fun getKey(desc: PropertyMetadata) = key(desc) + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() + } +} \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt b/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt new file mode 100644 index 00000000000..2d0767446d3 --- /dev/null +++ b/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt @@ -0,0 +1,75 @@ +package kotlin.properties.delegation.lazy + +private val NULL_VALUE: Any = Any() + +private fun escape(value: T): Any { + return if (value == null) NULL_VALUE else value +} + +private fun unescape(value: Any): T? { + return if (value == NULL_VALUE) null else value as T +} + +public open class LazyVal(initializer: () -> T): NullableLazyVal(initializer) { + override fun get(thisRef: Any?, desc: PropertyMetadata): T { + return super.get(thisRef, desc)!! + } +} + +public open class NullableLazyVal(private val initializer: () -> T?) { + private var value: Any? = null + + public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { + if (value == null) { + value = escape(initializer()) + } + return unescape(value!!) + } +} + +public open class VolatileLazyVal(initializer: () -> T): VolatileNullableLazyVal(initializer) { + override fun get(thisRef: Any?, desc: PropertyMetadata): T { + return super.get(thisRef, desc)!! + } +} + +public open class VolatileNullableLazyVal(private val initializer: () -> T?) { + private volatile var value: Any? = null + + public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { + if (value == null) { + value = escape(initializer()) + } + return unescape(value!!) + } +} + +public open class AtomicLazyVal(lock: Any? = null, initializer: () -> T): AtomicNullableLazyVal(lock, initializer) { + override fun get(thisRef: Any?, desc: PropertyMetadata): T { + return super.get(thisRef, desc)!! + } +} + +public open class AtomicNullableLazyVal(lock: Any? = null, private val initializer: () -> T?) { + private val lock = lock ?: this + private volatile var value: Any? = null + + public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { + val _v1 = value + if (_v1 != null) { + return unescape(_v1) + } + + return synchronized(lock) { + val _v2 = value + if (_v2 != null) { + unescape(_v2) + } + else { + val typedValue = initializer() + value = escape(typedValue) + typedValue + } + } + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/properties/delegation/DelegationTest.kt b/libraries/stdlib/test/properties/delegation/DelegationTest.kt new file mode 100644 index 00000000000..cceeeaf6af1 --- /dev/null +++ b/libraries/stdlib/test/properties/delegation/DelegationTest.kt @@ -0,0 +1,64 @@ +package test.properties.delegation + +import junit.framework.TestCase +import kotlin.test.* +import kotlin.properties.* +import kotlin.properties.delegation.* +import kotlin.properties.delegation.lazy.* + +trait WithBox { + fun box(): String +} + +abstract class DelegationTestBase: TestCase() { + fun doTest(klass: WithBox) { + assertEquals("OK", klass.box()) + } +} + +class DelegationTest(): DelegationTestBase() { + fun testNotNullVar() { + doTest(TestNotNullVar("a", "b")) + } + + fun testObservableProperty() { + doTest(TestObservableProperty()) + } +} + +public class TestNotNullVar(val a1: String, val b1: T): WithBox { + var a: String by NotNullVar() + var b by NotNullVar() + + override fun box(): String { + a = a1 + b = b1 + if (a != "a") return "fail: a shouuld be a, but was $a" + if (b != "b") return "fail: b should be b, but was $b" + return "OK" + } +} + +class TestObservableProperty: WithBox, ChangeSupport() { + + var b by property(init = 2) + var c by property(3) + + override fun box(): String { + var result = false + addChangeListener("b", object: ChangeListener { + public override fun onPropertyChange(event: ChangeEvent) { + result = true + } + }) + addChangeListener("c", object: ChangeListener { + public override fun onPropertyChange(event: ChangeEvent) { + result = false + } + }) + b = 4 + if (b != 4) return "fail: b != 4" + if (!result) return "fail: result should be true" + return "OK" + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt b/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt new file mode 100644 index 00000000000..9bc21c81c20 --- /dev/null +++ b/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt @@ -0,0 +1,224 @@ +package test.properties.delegation + +import java.util.HashMap +import kotlin.properties.delegation.* + +class MapDelegationTest(): DelegationTestBase() { + + fun testMapPropertyString() { + doTest(TestMapPropertyString()) + } + + fun testMapValWithDifferentTypes() { + doTest(TestMapValWithDifferentTypes()) + } + + fun testMapVarWithDifferentTypes() { + doTest(TestMapVarWithDifferentTypes()) + } + + fun testNullableKey() { + doTest(TestNullableKey()) + } + + fun testMapPropertyKey() { + doTest(TestMapPropertyKey()) + } + + fun testMapPropertyFunction() { + doTest(TestMapPropertyFunction()) + } + + fun testMapPropertyCustom() { + doTest(TestMapPropertyCustom()) + } + + fun testMapValWithDefault() { + doTest(TestMapValWithDefault()) + } + + fun testMapVarWithDefault() { + doTest(TestMapVarWithDefault()) + } + + fun testMapPropertyCustomWithDefault() { + doTest(TestMapPropertyCustomWithDefault()) + } +} + +class TestMapValWithDifferentTypes(): WithBox { + val map = hashMapOf("a" to "a", "b" to 1, "c" to A(1), "d" to null) + val a by map.readOnlyProperty() + val b by map.readOnlyProperty() + val c by map.readOnlyProperty() + val d by map.readOnlyProperty() + + override fun box(): String { + if (a != "a") return "fail at 'a'" + if (b != 1) return "fail at 'b'" + if (c != A(1)) return "fail at 'c'" + if (d != null) return "fail at 'd'" + return "OK" + } + + data class A(val a: Int) +} + +class TestMapVarWithDifferentTypes(): WithBox { + val map: HashMap = hashMapOf("a" to "a", "b" to 1, "c" to A(1), "d" to "d") + var a by map.property() + var b by map.property() + var c by map.property() + var d by map.property() + + override fun box(): String { + a = "aa" + b = 11 + c = A(11) + d = null + if (a != "aa") return "fail at 'a'" + if (b != 11) return "fail at 'b'" + if (c != A(11)) return "fail at 'c'" + if (d != null) return "fail at 'd'" + return "OK" + } + + data class A(val a: Int) +} + +class TestNullableKey: WithBox { + val map = hashMapOf(null to "null") + var a by map.property { desc -> null } + + override fun box(): String { + if (a != "null") return "fail at 'a'" + a = "foo" + if (a != "foo") return "fail at 'a' after set" + return "OK" + } +} + +class TestMapPropertyString(): WithBox { + val map = hashMapOf("a" to "a", "b" to "b", "c" to "c") + val a by map.readOnlyProperty() + var b by map.property() + val c by map.property() + + override fun box(): String { + b = "newB" + if (a != "a") return "fail at 'a'" + if (b != "newB") return "fail at 'b'" + if (c != "c") return "fail at 'c'" + return "OK" + } +} + +class TestMapValWithDefault(): WithBox { + val map = hashMapOf() + val a by map.readOnlyProperty(default = { "aDefault" }) + val b by map.readOnlyProperty(default = { "bDefault" }, key = "b") + val c by map.readOnlyProperty(default = { "cDefault" }, key = { desc -> desc.name }) + + override fun box(): String { + if (a != "aDefault") return "fail at 'a'" + if (b != "bDefault") return "fail at 'b'" + if (c != "cDefault") return "fail at 'c'" + return "OK" + } +} + +class TestMapVarWithDefault(): WithBox { + val map = hashMapOf() + var a by map.property(default = { "aDefault" }) + var b by map.property(default = { "bDefault" }, key = "b") + var c by map.property(default = { "cDefault" }, key = { desc -> desc.name }) + + override fun box(): String { + if (a != "aDefault") return "fail at 'a'" + if (b != "bDefault") return "fail at 'b'" + if (c != "cDefault") return "fail at 'c'" + a = "a" + b = "b" + c = "c" + if (a != "a") return "fail at 'a' after set" + if (b != "b") return "fail at 'b' after set" + if (c != "c") return "fail at 'c' after set" + return "OK" + } +} + +class TestMapPropertyKey(): WithBox { + val map = hashMapOf("a" to "a", "b" to "b") + val a by map.readOnlyProperty(key = "a") + var b by map.property(key = "b") + + override fun box(): String { + b = "c" + if (a != "a") return "fail at 'a'" + if (b != "c") return "fail at 'b'" + return "OK" + } +} + +class TestMapPropertyFunction(): WithBox { + val map = hashMapOf("aDesc" to "a", "bDesc" to "b") + val a by map.readOnlyProperty { desc -> "${desc.name}Desc" } + var b by map.property { desc -> "${desc.name}Desc" } + + override fun box(): String { + b = "c" + if (a != "a") return "fail at 'a'" + if (b != "c") return "fail at 'b' after set" + return "OK" + } +} + +val mapVal = object : MapVal() { + override fun getMap(thisRef: TestMapPropertyCustom) = thisRef.map + override fun getKey(desc: PropertyMetadata) = "${desc.name}Desc" +} +val mapVar = object : MapVar() { + override fun getMap(thisRef: TestMapPropertyCustom) = thisRef.map + override fun getKey(desc: PropertyMetadata) = "${desc.name}Desc" +} + +class TestMapPropertyCustom(): WithBox { + val map = hashMapOf("aDesc" to "a", "bDesc" to "b") + val a by mapVal + var b by mapVar + + override fun box(): String { + b = "newB" + if (a != "a") return "fail at 'a'" + if (b != "newB") return "fail at 'b' after set" + return "OK" + } +} + +val mapValWithDefault = object : MapVal() { + override fun getMap(thisRef: TestMapPropertyCustomWithDefault) = thisRef.map + override fun getKey(desc: PropertyMetadata) = desc.name + + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = "default" +} + +val mapVarWithDefault = object : MapVar() { + override fun getMap(thisRef: TestMapPropertyCustomWithDefault) = thisRef.map + override fun getKey(desc: PropertyMetadata) = desc.name + + override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = "default" +} + +class TestMapPropertyCustomWithDefault(): WithBox { + val map = hashMapOf() + val a by mapValWithDefault + var b by mapVarWithDefault + + override fun box(): String { + if (a != "default") return "fail at 'a'" + if (b != "default") return "fail at 'b'" + b = "c" + if (b != "c") return "fail at 'b' after set" + return "OK" + } +} \ No newline at end of file diff --git a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt new file mode 100644 index 00000000000..6a3a4cac847 --- /dev/null +++ b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt @@ -0,0 +1,143 @@ +package test.properties.delegation.lazy + +import kotlin.properties.delegation.lazy.* +import test.properties.delegation.WithBox +import test.properties.delegation.DelegationTestBase + +class LazyValuesTest(): DelegationTestBase() { + + fun testLazyVal() { + doTest(TestLazyVal()) + } + + fun testNullableLazyVal() { + doTest(TestNullableLazyVal()) + } + + fun testAtomicNullableLazyVal() { + doTest(TestAtomicNullableLazyVal()) + } + + fun testAtomicLazyVal() { + doTest(TestAtomicLazyVal()) + } + + fun testVolatileNullableLazyVal() { + doTest(TestVolatileNullableLazyVal()) + } + + fun testVolatileLazyVal() { + doTest(TestVolatileLazyVal()) + } +} + +class TestLazyVal: WithBox { + var result = 0 + val a by LazyVal { + ++result + } + + override fun box(): String { + a + if (a != 1) return "fail: initializer should be invoked only once" + return "OK" + } +} + +class TestNullableLazyVal: WithBox { + var resultA = 0 + var resultB = 0 + + val a: Int? by NullableLazyVal { resultA++; null} + val b by NullableLazyVal { foo() } + + override fun box(): String { + a + b + + if (a != null) return "fail: a should be null" + if (b != null) return "fail: a should be null" + if (resultA != 1) return "fail: initializer for a should be invoked only once" + if (resultB != 1) return "fail: initializer for b should be invoked only once" + return "OK" + } + + fun foo(): String? { + resultB++ + return null + } +} + +class TestAtomicLazyVal: WithBox { + var result = 0 + val a by AtomicLazyVal { + ++result + } + + override fun box(): String { + a + if (a != 1) return "fail: initializer should be invoked only once" + return "OK" + } +} + +class TestVolatileNullableLazyVal: WithBox { + var resultA = 0 + var resultB = 0 + + val a: Int? by VolatileNullableLazyVal { resultA++; null} + val b by VolatileNullableLazyVal { foo() } + + override fun box(): String { + a + b + + if (a != null) return "fail: a should be null" + if (b != null) return "fail: a should be null" + if (resultA != 1) return "fail: initializer for a should be invoked only once" + if (resultB != 1) return "fail: initializer for b should be invoked only once" + return "OK" + } + + fun foo(): String? { + resultB++ + return null + } +} + +class TestVolatileLazyVal: WithBox { + var result = 0 + val a by VolatileLazyVal { + ++result + } + + override fun box(): String { + a + if (a != 1) return "fail: initializer should be invoked only once" + return "OK" + } +} + +class TestAtomicNullableLazyVal: WithBox { + var resultA = 0 + var resultB = 0 + + val a: Int? by AtomicNullableLazyVal { resultA++; null} + val b by AtomicNullableLazyVal { foo() } + + override fun box(): String { + a + b + + if (a != null) return "fail: a should be null" + if (b != null) return "fail: a should be null" + if (resultA != 1) return "fail: initializer for a should be invoked only once" + if (resultB != 1) return "fail: initializer for b should be invoked only once" + return "OK" + } + + fun foo(): String? { + resultB++ + return null + } +} From a2b82095dae43057e11827045be3618704a7b4e6 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 21 May 2013 13:01:31 +0400 Subject: [PATCH 21/92] Using the version of ASM that has debug information in it No more need for extra ASM jars (analysis and util) --- .idea/artifacts/KotlinPlugin.xml | 1 - .idea/libraries/asm.xml | 2 +- .idea/libraries/asm_addons.xml | 12 ------------ build.xml | 4 +--- compiler/backend/backend.iml | 1 - compiler/cli/cli.iml | 1 - compiler/tests/compiler-tests.iml | 1 - update_dependencies.xml | 27 +++++++++++++-------------- 8 files changed, 15 insertions(+), 34 deletions(-) delete mode 100644 .idea/libraries/asm_addons.xml diff --git a/.idea/artifacts/KotlinPlugin.xml b/.idea/artifacts/KotlinPlugin.xml index 778180015dc..41a47a34c35 100644 --- a/.idea/artifacts/KotlinPlugin.xml +++ b/.idea/artifacts/KotlinPlugin.xml @@ -4,7 +4,6 @@ - diff --git a/.idea/libraries/asm.xml b/.idea/libraries/asm.xml index 8968222f967..13003cfe5f2 100644 --- a/.idea/libraries/asm.xml +++ b/.idea/libraries/asm.xml @@ -1,7 +1,7 @@ - + diff --git a/.idea/libraries/asm_addons.xml b/.idea/libraries/asm_addons.xml deleted file mode 100644 index 7488a22044c..00000000000 --- a/.idea/libraries/asm_addons.xml +++ /dev/null @@ -1,12 +0,0 @@ - - - - - - - - - - - - \ No newline at end of file diff --git a/build.xml b/build.xml index 632c0352eb8..182b6655096 100644 --- a/build.xml +++ b/build.xml @@ -18,7 +18,6 @@ - @@ -276,8 +275,7 @@ - - + diff --git a/compiler/backend/backend.iml b/compiler/backend/backend.iml index 9dd4449bbb4..e1b68dd0487 100644 --- a/compiler/backend/backend.iml +++ b/compiler/backend/backend.iml @@ -9,7 +9,6 @@ - diff --git a/compiler/cli/cli.iml b/compiler/cli/cli.iml index 3fc055ccfc9..f67af7c8ec3 100644 --- a/compiler/cli/cli.iml +++ b/compiler/cli/cli.iml @@ -13,7 +13,6 @@ - diff --git a/compiler/tests/compiler-tests.iml b/compiler/tests/compiler-tests.iml index da889f38b4b..c29422b9f46 100644 --- a/compiler/tests/compiler-tests.iml +++ b/compiler/tests/compiler-tests.iml @@ -14,7 +14,6 @@ - diff --git a/update_dependencies.xml b/update_dependencies.xml index 3fc8c81ac46..b3fe11a630b 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -123,28 +123,20 @@ - - - + - - - - - - - - + + - + @@ -194,7 +186,7 @@ - + @@ -227,7 +219,8 @@ - + + @@ -239,6 +232,12 @@ --> + + + From 4c9174d49b5fe0a6ced10870c870dcdb4d902169 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Tue, 21 May 2013 14:20:41 +0400 Subject: [PATCH 22/92] Don't create stubs for properties in delegate expression --- .../psi/stubs/elements/JetStubElementType.java | 15 +++++++++++---- .../jetbrains/jet/plugin/stubs/JetStubsTest.java | 6 ++++++ 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java index 434e812fe69..4cddb31a310 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetStubElementType.java @@ -23,10 +23,7 @@ import com.intellij.psi.stubs.StubElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetBlockExpression; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetFunctionLiteral; -import org.jetbrains.jet.lang.psi.JetWithExpressionInitializer; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.plugin.JetLanguage; public abstract class JetStubElementType extends IStubElementType { @@ -67,6 +64,16 @@ public abstract class JetStubElementType Date: Tue, 21 May 2013 16:26:40 +0400 Subject: [PATCH 23/92] KT-3575, KT-2297 Inserting pair for "${": reverting to use KotlinTypeHandler (with disabling JetPairMatcher for this case) --- .../org/jetbrains/jet/plugin/JetPairMatcher.java | 8 ++++++-- .../jet/plugin/editor/KotlinTypedHandler.java | 14 ++++++++++++++ .../org/jetbrains/jet/editor/TypedHandlerTest.java | 12 ++++++++++++ 3 files changed, 32 insertions(+), 2 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java index a97fdee0200..9bf05aa432b 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java @@ -39,8 +39,12 @@ public class JetPairMatcher implements PairedBraceMatcher { @Override public boolean isPairedBracesAllowedBeforeType(@NotNull IElementType lbraceType, @Nullable IElementType contextType) { - return lbraceType.equals(JetTokens.LONG_TEMPLATE_ENTRY_START) - || JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType) + if (lbraceType.equals(JetTokens.LONG_TEMPLATE_ENTRY_START)) { + // KotlinTypedHandler insert paired brace in this case + return false; + } + + return JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType) || contextType == JetTokens.SEMICOLON || contextType == JetTokens.COMMA || contextType == JetTokens.RPAR diff --git a/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java b/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java index b35d929710d..baedb696788 100644 --- a/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/KotlinTypedHandler.java @@ -57,6 +57,20 @@ public class KotlinTypedHandler extends TypedHandlerDelegate { JetLtGtTypingUtils.handleJetAutoCloseLT(editor); return Result.STOP; } + + if (!(file instanceof JetFile) || !CodeInsightSettings.getInstance().AUTOINSERT_PAIR_BRACKET) { + return Result.CONTINUE; + } + if (c == '{') { + PsiDocumentManager.getInstance(project).commitAllDocuments(); + int offset = editor.getCaretModel().getOffset(); + PsiElement previousElement = file.findElementAt(offset - 1); + if (previousElement instanceof LeafPsiElement + && ((LeafPsiElement) previousElement).getElementType() == JetTokens.LONG_TEMPLATE_ENTRY_START) { + editor.getDocument().insertString(offset, "}"); + } + return Result.STOP; + } return Result.CONTINUE; } } diff --git a/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java b/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java index 5ac75e43c72..998a88535cf 100644 --- a/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java +++ b/idea/tests/org/jetbrains/jet/editor/TypedHandlerTest.java @@ -26,6 +26,18 @@ public class TypedHandlerTest extends LightCodeInsightTestCase { checkResultByText("val x = \"${}\""); } + public void testTypeStringTemplateStartWithCloseBraceAfter() throws Exception { + configureFromFileText("a.kt", "fun foo() { \"$\" }"); + EditorTestUtil.performTypingAction(getEditor(), '{'); + checkResultByText("fun foo() { \"${}\" }"); + } + + public void testTypeStringTemplateStartBeforeString() throws Exception { + configureFromFileText("a.kt", "fun foo() { \"$something\" }"); + EditorTestUtil.performTypingAction(getEditor(), '{'); + checkResultByText("fun foo() { \"${}something\" }"); + } + public void testKT3575() throws Exception { configureFromFileText("a.kt", "val x = \"$]\""); EditorTestUtil.performTypingAction(getEditor(), '{'); From 86d60aea9fbef7a40546cb1f12f12deb3df93b31 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 8 May 2013 16:12:13 +0400 Subject: [PATCH 24/92] Minor. Replaced for with for each. --- .../jet/lang/descriptors/impl/FunctionDescriptorUtil.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/FunctionDescriptorUtil.java index 1384d15a7b6..9959f4e9ba7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/FunctionDescriptorUtil.java @@ -71,8 +71,7 @@ public class FunctionDescriptorUtil { public static List getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, @NotNull TypeSubstitutor substitutor) { List result = new ArrayList(); List unsubstitutedValueParameters = functionDescriptor.getValueParameters(); - for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { - ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); + for (ValueParameterDescriptor unsubstitutedValueParameter : unsubstitutedValueParameters) { // TODO : Lazy? JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getType(), Variance.IN_VARIANCE); JetType varargElementType = unsubstitutedValueParameter.getVarargElementType(); From 6f7d42185f559c82beb07f6741c38275c7aea7be Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 17 May 2013 19:14:36 +0400 Subject: [PATCH 25/92] Added dependency class resolver -> function resolver. --- .../di/InjectorForJavaDescriptorResolver.java | 49 ++++++++++--------- .../di/InjectorForJavaSemanticServices.java | 49 ++++++++++--------- .../di/InjectorForTopDownAnalyzerForJvm.java | 49 ++++++++++--------- .../java/resolver/JavaClassResolver.java | 7 ++- 4 files changed, 81 insertions(+), 73 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 0af9b9e9d41..abca44baa87 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -30,11 +30,11 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; import org.jetbrains.annotations.NotNull; @@ -57,11 +57,11 @@ public class InjectorForJavaDescriptorResolver { private JavaCompileTimeConstResolver javaCompileTimeConstResolver; private JavaClassObjectResolver javaClassObjectResolver; private JavaSupertypeResolver javaSupertypeResolver; - private JavaNamespaceResolver javaNamespaceResolver; - private JavaSignatureResolver javaSignatureResolver; - private JavaConstructorResolver javaConstructorResolver; - private JavaValueParameterResolver javaValueParameterResolver; private JavaFunctionResolver javaFunctionResolver; + private JavaValueParameterResolver javaValueParameterResolver; + private JavaSignatureResolver javaSignatureResolver; + private JavaNamespaceResolver javaNamespaceResolver; + private JavaConstructorResolver javaConstructorResolver; private JavaInnerClassResolver javaInnerClassResolver; private JavaPropertyResolver javaPropertyResolver; @@ -84,11 +84,11 @@ public class InjectorForJavaDescriptorResolver { this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); this.javaClassObjectResolver = new JavaClassObjectResolver(); this.javaSupertypeResolver = new JavaSupertypeResolver(); - this.javaNamespaceResolver = new JavaNamespaceResolver(); - this.javaSignatureResolver = new JavaSignatureResolver(); - this.javaConstructorResolver = new JavaConstructorResolver(); - this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); + this.javaValueParameterResolver = new JavaValueParameterResolver(); + this.javaSignatureResolver = new JavaSignatureResolver(); + this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -114,6 +114,7 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); + javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -136,24 +137,24 @@ public class InjectorForJavaDescriptorResolver { javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); - javaNamespaceResolver.setPsiClassFinder(psiClassFinder); - javaNamespaceResolver.setTrace(bindingTrace); - - javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); - - javaConstructorResolver.setTrace(bindingTrace); - javaConstructorResolver.setTypeTransformer(javaTypeTransformer); - javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); - - javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); javaFunctionResolver.setTrace(bindingTrace); javaFunctionResolver.setTypeTransformer(javaTypeTransformer); + javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); + + javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); + javaNamespaceResolver.setPsiClassFinder(psiClassFinder); + javaNamespaceResolver.setTrace(bindingTrace); + + javaConstructorResolver.setTrace(bindingTrace); + javaConstructorResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); + javaInnerClassResolver.setClassResolver(javaClassResolver); javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 50e3e0780df..809bf1da9af 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -30,11 +30,11 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; import org.jetbrains.annotations.NotNull; @@ -57,11 +57,11 @@ public class InjectorForJavaSemanticServices { private JavaCompileTimeConstResolver javaCompileTimeConstResolver; private JavaClassObjectResolver javaClassObjectResolver; private JavaSupertypeResolver javaSupertypeResolver; - private JavaNamespaceResolver javaNamespaceResolver; - private JavaSignatureResolver javaSignatureResolver; - private JavaConstructorResolver javaConstructorResolver; - private JavaValueParameterResolver javaValueParameterResolver; private JavaFunctionResolver javaFunctionResolver; + private JavaValueParameterResolver javaValueParameterResolver; + private JavaSignatureResolver javaSignatureResolver; + private JavaNamespaceResolver javaNamespaceResolver; + private JavaConstructorResolver javaConstructorResolver; private JavaInnerClassResolver javaInnerClassResolver; private JavaPropertyResolver javaPropertyResolver; @@ -82,11 +82,11 @@ public class InjectorForJavaSemanticServices { this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); this.javaClassObjectResolver = new JavaClassObjectResolver(); this.javaSupertypeResolver = new JavaSupertypeResolver(); - this.javaNamespaceResolver = new JavaNamespaceResolver(); - this.javaSignatureResolver = new JavaSignatureResolver(); - this.javaConstructorResolver = new JavaConstructorResolver(); - this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); + this.javaValueParameterResolver = new JavaValueParameterResolver(); + this.javaSignatureResolver = new JavaSignatureResolver(); + this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -114,6 +114,7 @@ public class InjectorForJavaSemanticServices { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); + javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -136,24 +137,24 @@ public class InjectorForJavaSemanticServices { javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); - javaNamespaceResolver.setPsiClassFinder(psiClassFinder); - javaNamespaceResolver.setTrace(bindingTrace); - - javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); - - javaConstructorResolver.setTrace(bindingTrace); - javaConstructorResolver.setTypeTransformer(javaTypeTransformer); - javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); - - javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); javaFunctionResolver.setTrace(bindingTrace); javaFunctionResolver.setTypeTransformer(javaTypeTransformer); + javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); + + javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); + javaNamespaceResolver.setPsiClassFinder(psiClassFinder); + javaNamespaceResolver.setTrace(bindingTrace); + + javaConstructorResolver.setTrace(bindingTrace); + javaConstructorResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); + javaInnerClassResolver.setClassResolver(javaClassResolver); javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 653d2ef6547..f39ccfdc0bc 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -54,11 +54,11 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassObjectResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver; import org.jetbrains.annotations.NotNull; @@ -105,11 +105,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private JavaCompileTimeConstResolver javaCompileTimeConstResolver; private JavaClassObjectResolver javaClassObjectResolver; private JavaSupertypeResolver javaSupertypeResolver; - private JavaNamespaceResolver javaNamespaceResolver; - private JavaSignatureResolver javaSignatureResolver; - private JavaConstructorResolver javaConstructorResolver; - private JavaValueParameterResolver javaValueParameterResolver; private JavaFunctionResolver javaFunctionResolver; + private JavaValueParameterResolver javaValueParameterResolver; + private JavaSignatureResolver javaSignatureResolver; + private JavaNamespaceResolver javaNamespaceResolver; + private JavaConstructorResolver javaConstructorResolver; private JavaInnerClassResolver javaInnerClassResolver; private JavaPropertyResolver javaPropertyResolver; @@ -157,11 +157,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); this.javaClassObjectResolver = new JavaClassObjectResolver(); this.javaSupertypeResolver = new JavaSupertypeResolver(); - this.javaNamespaceResolver = new JavaNamespaceResolver(); - this.javaSignatureResolver = new JavaSignatureResolver(); - this.javaConstructorResolver = new JavaConstructorResolver(); - this.javaValueParameterResolver = new JavaValueParameterResolver(); this.javaFunctionResolver = new JavaFunctionResolver(); + this.javaValueParameterResolver = new JavaValueParameterResolver(); + this.javaSignatureResolver = new JavaSignatureResolver(); + this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); @@ -287,6 +287,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setClassObjectResolver(javaClassObjectResolver); + javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSemanticServices(javaSemanticServices); @@ -309,24 +310,24 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); - javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); - javaNamespaceResolver.setPsiClassFinder(psiClassFinder); - javaNamespaceResolver.setTrace(bindingTrace); - - javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); - - javaConstructorResolver.setTrace(bindingTrace); - javaConstructorResolver.setTypeTransformer(javaTypeTransformer); - javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); - - javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); - javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); javaFunctionResolver.setParameterResolver(javaValueParameterResolver); javaFunctionResolver.setSignatureResolver(javaSignatureResolver); javaFunctionResolver.setTrace(bindingTrace); javaFunctionResolver.setTypeTransformer(javaTypeTransformer); + javaValueParameterResolver.setTypeTransformer(javaTypeTransformer); + + javaSignatureResolver.setJavaSemanticServices(javaSemanticServices); + + javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); + javaNamespaceResolver.setPsiClassFinder(psiClassFinder); + javaNamespaceResolver.setTrace(bindingTrace); + + javaConstructorResolver.setTrace(bindingTrace); + javaConstructorResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); + javaInnerClassResolver.setClassResolver(javaClassResolver); javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 2d0dcf5c172..5e2032d01fc 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.java.provider.MembersCache; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -80,6 +79,7 @@ public final class JavaClassResolver { private JavaNamespaceResolver namespaceResolver; private JavaClassObjectResolver classObjectResolver; private JavaSupertypeResolver supertypesResolver; + private JavaFunctionResolver functionResolver; public JavaClassResolver() { } @@ -124,6 +124,11 @@ public final class JavaClassResolver { this.supertypesResolver = supertypesResolver; } + @Inject + public void setFunctionResolver(JavaFunctionResolver functionResolver) { + this.functionResolver = functionResolver; + } + @Nullable public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { PostponedTasks postponedTasks = new PostponedTasks(); From 5fc7c885bb121c38f278af9f500fc49599bc3dca Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 17 May 2013 20:54:36 +0400 Subject: [PATCH 26/92] KT-3577 Stack overflow when resolving SAM adapter (from completion, show parameters, etc) #KT-3577 --- .../ClassDescriptorFromJvmBytecode.java | 16 ++-- .../resolve/java/provider/MembersCache.java | 24 ++++-- .../resolver/JavaClassObjectResolver.java | 4 +- .../java/resolver/JavaClassResolver.java | 13 +++- .../java/resolver/JavaFunctionResolver.java | 27 ++++--- .../java/sam/SingleAbstractMethodUtils.java | 76 +++++++++++++++---- .../adapter/DeepSamLoop.java | 12 +++ .../adapter/DeepSamLoop.txt | 19 +++++ .../adapter/SelfAsParameter.java | 5 ++ .../adapter/SelfAsParameter.txt | 8 ++ .../jvm/compiler/LoadJavaTestGenerated.java | 10 +++ 11 files changed, 174 insertions(+), 40 deletions(-) create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.java create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.txt create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.java create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.txt diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java index e2e95710cb7..25e3dcfc48e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/ClassDescriptorFromJvmBytecode.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; +import org.jetbrains.jet.lang.types.JetType; import java.util.Collection; @@ -30,18 +31,16 @@ import java.util.Collection; * @see org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor */ public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite { - private final boolean isSamInterface; + private JetType functionTypeForSamInterface; private JavaClassNonStaticMembersScope scopeForConstructorResolve; public ClassDescriptorFromJvmBytecode( @NotNull DeclarationDescriptor containingDeclaration, @NotNull ClassKind kind, - boolean isInner, - boolean isSamInterface + boolean isInner ) { super(containingDeclaration, kind, isInner); - this.isSamInterface = isSamInterface; } @@ -62,7 +61,12 @@ public class ClassDescriptorFromJvmBytecode extends MutableClassDescriptorLite { this.scopeForConstructorResolve = scopeForConstructorResolve; } - public boolean isSamInterface() { - return isSamInterface; + @Nullable + public JetType getFunctionTypeForSamInterface() { + return functionTypeForSamInterface; + } + + public void setFunctionTypeForSamInterface(@NotNull JetType functionTypeForSamInterface) { + this.functionTypeForSamInterface = functionTypeForSamInterface; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index f5b6fa5777b..5c305bcfcee 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import com.intellij.psi.*; import com.intellij.psi.util.PsiFormatUtil; @@ -402,28 +403,37 @@ public final class MembersCache { } public static boolean isSamInterface(@NotNull PsiClass psiClass) { + return getSamInterfaceMethod(psiClass) != null; + } + + // Returns null if not SAM interface + @Nullable + public static PsiMethod getSamInterfaceMethod(@NotNull PsiClass psiClass) { + if (psiClass.hasModifierProperty(PsiModifier.PRIVATE)) { // TODO hacky + return null; + } if (DescriptorResolverUtils.isKotlinClass(psiClass)) { - return false; + return null; } String qualifiedName = psiClass.getQualifiedName(); if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.getFqName() + ".")) { - return false; + return null; } if (!psiClass.isInterface() || psiClass.isAnnotationType()) { - return false; + return null; } - int foundAbstractMethods = 0; + List methods = Lists.newArrayList(); for (PsiMethod method : psiClass.getAllMethods()) { if (!isObjectMethod(method) && method.hasModifierProperty(PsiModifier.ABSTRACT)) { - foundAbstractMethods++; + methods.add(method); if (method.hasTypeParameters()) { - return false; + return null; } } } - return foundAbstractMethods == 1; + return methods.size() == 1 ? methods.get(0) : null; } private static abstract class RunOnce implements Runnable { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java index 2a9c3c3f286..50cac772c7b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java @@ -100,7 +100,7 @@ public final class JavaClassObjectResolver { FqName fqName = new FqName(qualifiedName); ClassPsiDeclarationProvider classObjectData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(classObjectPsiClass); ClassDescriptorFromJvmBytecode classObjectDescriptor - = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false, false); + = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); classObjectDescriptor.setSupertypes(supertypesResolver.getSupertypes(classObjectDescriptor, new PsiClassWrapper(classObjectPsiClass), classObjectData, @@ -129,7 +129,7 @@ public final class JavaClassObjectResolver { ) { FqNameUnsafe fqName = DescriptorResolverUtils.getFqNameForClassObject(psiClass); ClassDescriptorFromJvmBytecode classObjectDescriptor = - new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false, false); + new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass); setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().getName())); return classObjectDescriptor; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 5e2032d01fc..edb7177da25 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -20,6 +20,7 @@ import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; import gnu.trove.THashMap; import gnu.trove.TObjectHashingStrategy; @@ -33,8 +34,11 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; +import org.jetbrains.jet.lang.resolve.java.provider.MembersCache; +import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; +import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameBase; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -234,7 +238,7 @@ public final class JavaClassResolver { ClassKind kind = getClassKind(psiClass, jetClassAnnotation); ClassPsiDeclarationProvider classData = semanticServices.getPsiDeclarationProviderFactory().createBinaryClassData(psiClass); ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode( - containingDeclaration, kind, isInnerClass(psiClass), MembersCache.isSamInterface(psiClass)); + containingDeclaration, kind, isInnerClass(psiClass)); cache(javaClassToKotlinFqName(fqName), classDescriptor); classDescriptor.setName(Name.identifier(psiClass.getName())); @@ -269,6 +273,13 @@ public final class JavaClassResolver { trace.record(BindingContext.CLASS, psiClass, classDescriptor); + PsiMethod samInterfaceMethod = MembersCache.getSamInterfaceMethod(psiClass); + if (samInterfaceMethod != null) { + SimpleFunctionDescriptor abstractMethod = functionResolver.resolveFunctionMutely( + psiClass, new PsiMethodWrapper(samInterfaceMethod), classDescriptor); + classDescriptor.setFunctionTypeForSamInterface(SingleAbstractMethodUtils.getFunctionTypeForAbstractMethod(abstractMethod)); + } + return classDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 01f84197a25..8d2e5dd7a40 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -34,10 +34,7 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData; import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; -import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; -import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProvider; +import org.jetbrains.jet.lang.resolve.java.provider.*; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; @@ -93,10 +90,18 @@ public final class JavaFunctionResolver { this.annotationResolver = annotationResolver; } + @Nullable + SimpleFunctionDescriptor resolveFunctionMutely( + @NotNull PsiClass psiClass, PsiMethodWrapper method, + @NotNull ClassOrNamespaceDescriptor ownerDescriptor + ) { + return resolveMethodToFunctionDescriptor(psiClass, method, DeclarationOrigin.JAVA, ownerDescriptor, false); + } + @Nullable private SimpleFunctionDescriptor resolveMethodToFunctionDescriptor( @NotNull PsiClass psiClass, PsiMethodWrapper method, - @NotNull PsiDeclarationProvider scopeData, @NotNull ClassOrNamespaceDescriptor ownerDescriptor + @NotNull DeclarationOrigin declarationOrigin, @NotNull ClassOrNamespaceDescriptor ownerDescriptor, boolean record ) { if (!DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, method.getPsiMember())) { return null; @@ -114,7 +119,7 @@ public final class JavaFunctionResolver { PsiMethod psiMethod = method.getPsiMethod(); PsiClass containingClass = psiMethod.getContainingClass(); - if (scopeData.getDeclarationOrigin() == KOTLIN) { + if (declarationOrigin == KOTLIN) { // TODO: unless maybe class explicitly extends Object assert containingClass != null; String ownerClassName = containingClass.getQualifiedName(); @@ -189,11 +194,11 @@ public final class JavaFunctionResolver { /*isInline = */ false ); - if (functionDescriptorImpl.getKind() == CallableMemberDescriptor.Kind.DECLARATION) { + if (functionDescriptorImpl.getKind() == CallableMemberDescriptor.Kind.DECLARATION && record) { BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, psiMethod, functionDescriptorImpl); } - if (scopeData.getDeclarationOrigin() == JAVA) { + if (declarationOrigin == JAVA && record) { trace.record(BindingContext.IS_DECLARED_IN_JAVA, functionDescriptorImpl); } @@ -208,7 +213,9 @@ public final class JavaFunctionResolver { checkFunctionsOverrideCorrectly(method, superFunctions, functionDescriptorImpl); } else { - trace.record(BindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, functionDescriptorImpl, signatureErrors); + if (record) { + trace.record(BindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, functionDescriptorImpl, signatureErrors); + } } } @@ -267,7 +274,7 @@ public final class JavaFunctionResolver { Set functionsFromCurrent = Sets.newHashSet(); for (PsiMethodWrapper method : namedMembers.getMethods()) { - SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData, owner); + SimpleFunctionDescriptor function = resolveMethodToFunctionDescriptor(psiClass, method, scopeData.getDeclarationOrigin(), owner, true); if (function != null) { functionsFromCurrent.add(function); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java index 76aa59c2aaf..bc89a2d42e0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java @@ -27,10 +27,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeSubstitutor; -import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.Variance; +import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Arrays; @@ -38,7 +35,10 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import static org.jetbrains.jet.lang.types.Variance.INVARIANT; + public class SingleAbstractMethodUtils { + @NotNull private static List getAbstractMembers(@NotNull JetType type) { List abstractMembers = Lists.newArrayList(); @@ -52,18 +52,67 @@ public class SingleAbstractMethodUtils { return abstractMembers; } - @NotNull + // TODO maybe do this in substitutor? + private static JetType fixProjections(@NotNull JetType functionType) { + //removes redundant projection kinds and detects conflicts + + List arguments = Lists.newArrayList(); + for (TypeParameterDescriptor typeParameter : functionType.getConstructor().getParameters()) { + Variance variance = typeParameter.getVariance(); + TypeProjection argument = functionType.getArguments().get(typeParameter.getIndex()); + Variance kind = argument.getProjectionKind(); + if (kind != INVARIANT && variance != INVARIANT) { + if (kind == variance) { + arguments.add(new TypeProjection(argument.getType())); + } + else { + return null; + } + } + else { + arguments.add(argument); + } + } + ClassifierDescriptor classifier = functionType.getConstructor().getDeclarationDescriptor(); + assert classifier instanceof ClassDescriptor : "Not class: " + classifier; + return new JetTypeImpl( + functionType.getAnnotations(), + functionType.getConstructor(), + functionType.isNullable(), + arguments, + ((ClassDescriptor) classifier).getMemberScope(arguments) + ); + } + + @Nullable private static JetType getFunctionTypeForSamType(@NotNull JetType samType) { - FunctionDescriptor function = getAbstractMethodOfSamType(samType); + // e.g. samType == Comparator? + + ClassifierDescriptor classifier = samType.getConstructor().getDeclarationDescriptor(); + if (classifier instanceof ClassDescriptorFromJvmBytecode) { + // Function2 + JetType functionTypeDefault = ((ClassDescriptorFromJvmBytecode) classifier).getFunctionTypeForSamInterface(); + + if (functionTypeDefault != null) { + // Function2? + JetType substitute = TypeSubstitutor.create(samType).substitute(functionTypeDefault, Variance.INVARIANT); + + return substitute == null ? null : fixProjections(TypeUtils.makeNullableAsSpecified(substitute, samType.isNullable())); + } + } + return null; + } + + @NotNull + public static JetType getFunctionTypeForAbstractMethod(@NotNull FunctionDescriptor function) { JetType returnType = function.getReturnType(); assert returnType != null : "function is not initialized: " + function; List parameterTypes = Lists.newArrayList(); for (ValueParameterDescriptor parameter : function.getValueParameters()) { parameterTypes.add(parameter.getType()); } - JetType functionType = KotlinBuiltIns.getInstance() - .getFunctionType(Collections.emptyList(), null, parameterTypes, returnType); - return TypeUtils.makeNullableAsSpecified(functionType, samType.isNullable()); + return KotlinBuiltIns.getInstance().getFunctionType( + Collections.emptyList(), null, parameterTypes, returnType); } private static boolean isSamInterface(@NotNull ClassDescriptor klass) { @@ -98,6 +147,7 @@ public class SingleAbstractMethodUtils { TypeParameters typeParameters = recreateAndInitializeTypeParameters(samInterface.getTypeConstructor().getParameters(), result); JetType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType()); + assert parameterTypeUnsubstituted != null : "couldn't get function type for SAM type" + samInterface.getDefaultType(); JetType parameterType = typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE); assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParameters.substitutor; ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl( @@ -121,10 +171,7 @@ public class SingleAbstractMethodUtils { } public static boolean isSamType(@NotNull JetType type) { - ClassifierDescriptor classifier = type.getConstructor().getDeclarationDescriptor(); - return classifier instanceof ClassDescriptorFromJvmBytecode && - ((ClassDescriptorFromJvmBytecode) classifier).isSamInterface() && - getAbstractMembers(type).size() == 1; // Comparator<*> is not a SAM type, because substituted compare() method doesn't exist + return getFunctionTypeForSamType(type) != null; } public static boolean isSamAdapterNecessary(@NotNull SimpleFunctionDescriptor fun) { @@ -155,7 +202,8 @@ public class SingleAbstractMethodUtils { List valueParameters = Lists.newArrayList(); for (ValueParameterDescriptor originalParam : original.getValueParameters()) { JetType originalType = originalParam.getType(); - JetType newTypeUnsubstituted = isSamType(originalType) ? getFunctionTypeForSamType(originalType) : originalType; + JetType functionType = getFunctionTypeForSamType(originalType); + JetType newTypeUnsubstituted = functionType != null ? functionType : originalType; JetType newType = typeParameters.substitutor.substitute(newTypeUnsubstituted, Variance.IN_VARIANCE); assert newType != null : "couldn't substitute type: " + newTypeUnsubstituted + ", substitutor = " + typeParameters.substitutor; diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.java b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.java new file mode 100644 index 00000000000..25835b936cd --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.java @@ -0,0 +1,12 @@ +package test; + +public interface DeepSamLoop { + + interface Foo { + void foo(Bar p); + } + + interface Bar { + void foo(Foo p); + } +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.txt b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.txt new file mode 100644 index 00000000000..d558ccd28f4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.txt @@ -0,0 +1,19 @@ +package test + +public trait DeepSamLoop : java.lang.Object { + + public trait Bar : java.lang.Object { + public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.DeepSamLoop.Bar?) -> jet.Unit)?): jet.Unit + public abstract fun foo(/*0*/ p0: test.DeepSamLoop.Foo?): jet.Unit + } + + public trait Foo : java.lang.Object { + public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.DeepSamLoop.Foo?) -> jet.Unit)?): jet.Unit + public abstract fun foo(/*0*/ p0: test.DeepSamLoop.Bar?): jet.Unit + } +} + +package DeepSamLoop { + public /*synthesized*/ fun Bar(/*0*/ function: (test.DeepSamLoop.Foo?) -> jet.Unit): test.DeepSamLoop.Bar + public /*synthesized*/ fun Foo(/*0*/ function: (test.DeepSamLoop.Bar?) -> jet.Unit): test.DeepSamLoop.Foo +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.java b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.java new file mode 100644 index 00000000000..f24f93f9114 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.java @@ -0,0 +1,5 @@ +package test; + +public interface SelfAsParameter { + void foo(SelfAsParameter p); +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.txt b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.txt new file mode 100644 index 00000000000..d579c380a55 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.txt @@ -0,0 +1,8 @@ +package test + +public /*synthesized*/ fun SelfAsParameter(/*0*/ function: (test.SelfAsParameter?) -> jet.Unit): test.SelfAsParameter + +public trait SelfAsParameter : java.lang.Object { + public abstract /*synthesized*/ fun foo(/*0*/ p0: ((test.SelfAsParameter?) -> jet.Unit)?): jet.Unit + public abstract fun foo(/*0*/ p0: test.SelfAsParameter?): jet.Unit +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index faf788d6631..6506c2d5255 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -1229,11 +1229,21 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/Basic.java"); } + @TestMetadata("DeepSamLoop.java") + public void testDeepSamLoop() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/DeepSamLoop.java"); + } + @TestMetadata("NonTrivialFunctionType.java") public void testNonTrivialFunctionType() throws Exception { doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/NonTrivialFunctionType.java"); } + @TestMetadata("SelfAsParameter.java") + public void testSelfAsParameter() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SelfAsParameter.java"); + } + @TestMetadata("SeveralSamParameters.java") public void testSeveralSamParameters() throws Exception { doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter/SeveralSamParameters.java"); From 12485c0ef5f08b6fdd219d7af20c466053be5f5b Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 13:14:28 +0400 Subject: [PATCH 27/92] Test for KT-3331 RuntimeException in frontend-java at TypeVariableResolverFromTypeDescriptors.getTypeVariable() #KT-3331 obsolete --- .../loadKotlin/class/InheritSubstitutedMethod.kt | 10 ++++++++++ .../loadKotlin/class/InheritSubstitutedMethod.txt | 12 ++++++++++++ .../compiler/LoadCompiledKotlinTestGenerated.java | 5 +++++ 3 files changed, 27 insertions(+) create mode 100644 compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt create mode 100644 compiler/testData/loadKotlin/class/InheritSubstitutedMethod.txt diff --git a/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt b/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt new file mode 100644 index 00000000000..c8e64d4e0e0 --- /dev/null +++ b/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt @@ -0,0 +1,10 @@ +package test + +public trait A { + fun bar(): T + fun foo(): T = bar() +} + +public class B : A { + override fun bar() = "" +} diff --git a/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.txt b/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.txt new file mode 100644 index 00000000000..f8220df53ad --- /dev/null +++ b/compiler/testData/loadKotlin/class/InheritSubstitutedMethod.txt @@ -0,0 +1,12 @@ +package test + +public trait A { + internal abstract fun bar(): T + internal open fun foo(): T +} + +public final class B : test.A { + /*primary*/ public constructor B() + internal open override /*1*/ fun bar(): jet.String + internal open override /*1*/ /*fake_override*/ fun foo(): jet.String +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java index 5c32db7fb29..89e993dc3e8 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java @@ -128,6 +128,11 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT doTestWithAccessors("compiler/testData/loadKotlin/class/InheritClassWithParam.kt"); } + @TestMetadata("InheritSubstitutedMethod.kt") + public void testInheritSubstitutedMethod() throws Exception { + doTestWithAccessors("compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt"); + } + @TestMetadata("InheritTraitWithParam.kt") public void testInheritTraitWithParam() throws Exception { doTestWithAccessors("compiler/testData/loadKotlin/class/InheritTraitWithParam.kt"); From fb416418f0c2f1bd84a40c4ce574dd0599183875 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 14:19:56 +0400 Subject: [PATCH 28/92] Minor. Fixed assertion message. --- .../jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java index bc89a2d42e0..dc8c30aa1e0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java @@ -147,7 +147,7 @@ public class SingleAbstractMethodUtils { TypeParameters typeParameters = recreateAndInitializeTypeParameters(samInterface.getTypeConstructor().getParameters(), result); JetType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType()); - assert parameterTypeUnsubstituted != null : "couldn't get function type for SAM type" + samInterface.getDefaultType(); + assert parameterTypeUnsubstituted != null : "couldn't get function type for SAM type " + samInterface.getDefaultType(); JetType parameterType = typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE); assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParameters.substitutor; ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl( From de6d5a4a96f3757e8eed6d116b637712a100ebd5 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 16:37:24 +0400 Subject: [PATCH 29/92] Fixed loading SAM interfaces when they inherit abstract methods. --- .../resolve/java/provider/MembersCache.java | 3 -- .../java/resolver/JavaClassResolver.java | 34 +++++++++++++++++-- .../java/resolver/JavaFunctionResolver.java | 6 ++-- .../java/sam/SingleAbstractMethodUtils.java | 2 +- .../SubstitutedSamInterface.java | 6 ++++ .../SubstitutedSamInterface.txt | 7 ++++ ...stitutedSamInterfaceSubclassOfBuiltin.java | 4 +++ ...bstitutedSamInterfaceSubclassOfBuiltin.txt | 7 ++++ .../jvm/compiler/LoadJavaTestGenerated.java | 10 ++++++ ...esolveNamespaceComparingTestGenerated.java | 5 +++ 10 files changed, 76 insertions(+), 8 deletions(-) create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.java create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.txt create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.java create mode 100644 compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.txt diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index 5c305bcfcee..1b3eaa095d8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -409,9 +409,6 @@ public final class MembersCache { // Returns null if not SAM interface @Nullable public static PsiMethod getSamInterfaceMethod(@NotNull PsiClass psiClass) { - if (psiClass.hasModifierProperty(PsiModifier.PRIVATE)) { // TODO hacky - return null; - } if (DescriptorResolverUtils.isKotlinClass(psiClass)) { return null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index edb7177da25..980ad38d540 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -44,6 +44,8 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeSubstitutor; +import org.jetbrains.jet.lang.types.TypeUtils; import javax.inject.Inject; import java.util.ArrayList; @@ -275,14 +277,42 @@ public final class JavaClassResolver { PsiMethod samInterfaceMethod = MembersCache.getSamInterfaceMethod(psiClass); if (samInterfaceMethod != null) { - SimpleFunctionDescriptor abstractMethod = functionResolver.resolveFunctionMutely( - psiClass, new PsiMethodWrapper(samInterfaceMethod), classDescriptor); + SimpleFunctionDescriptor abstractMethod = resolveFunctionOfSamInterface(psiClass, samInterfaceMethod, classDescriptor); classDescriptor.setFunctionTypeForSamInterface(SingleAbstractMethodUtils.getFunctionTypeForAbstractMethod(abstractMethod)); } return classDescriptor; } + @NotNull + private SimpleFunctionDescriptor resolveFunctionOfSamInterface( + @NotNull PsiClass psiClass, + @NotNull PsiMethod samInterfaceMethod, + @NotNull ClassDescriptorFromJvmBytecode samInterface + ) { + PsiClass methodContainer = samInterfaceMethod.getContainingClass(); + assert methodContainer != null : "method container is null for " + methodContainer; + String containerQualifiedName = methodContainer.getQualifiedName(); + assert containerQualifiedName != null : "qualified name is null for " + psiClass; + + if (DescriptorUtils.getFQName(samInterface).getFqName().equals(containerQualifiedName)) { + SimpleFunctionDescriptor abstractMethod = + functionResolver.resolveFunctionMutely(new PsiMethodWrapper(samInterfaceMethod), samInterface); + assert abstractMethod != null : "couldn't resolve method " + samInterfaceMethod; + return abstractMethod; + } + else { + Set supertypes = TypeUtils.getAllSupertypes(samInterface.getDefaultType()); + for (JetType supertype : supertypes) { + List abstractMembers = SingleAbstractMethodUtils.getAbstractMembers(supertype); + if (!abstractMembers.isEmpty()) { + return (SimpleFunctionDescriptor) abstractMembers.get(0); + } + } + throw new IllegalStateException("Couldn't find abstract method in supertypes " + supertypes); + } + } + private void cache(@NotNull FqNameBase fqName, @Nullable ClassDescriptor classDescriptor) { if (classDescriptor == null) { cacheNegativeValue(fqName); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 8d2e5dd7a40..5a6ca428aaf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -92,10 +92,12 @@ public final class JavaFunctionResolver { @Nullable SimpleFunctionDescriptor resolveFunctionMutely( - @NotNull PsiClass psiClass, PsiMethodWrapper method, + @NotNull PsiMethodWrapper method, @NotNull ClassOrNamespaceDescriptor ownerDescriptor ) { - return resolveMethodToFunctionDescriptor(psiClass, method, DeclarationOrigin.JAVA, ownerDescriptor, false); + PsiClass containingClass = method.getPsiMethod().getContainingClass(); + assert containingClass != null : "containing class is null for " + method; + return resolveMethodToFunctionDescriptor(containingClass, method, DeclarationOrigin.JAVA, ownerDescriptor, false); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java index dc8c30aa1e0..791161d5abc 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java @@ -40,7 +40,7 @@ import static org.jetbrains.jet.lang.types.Variance.INVARIANT; public class SingleAbstractMethodUtils { @NotNull - private static List getAbstractMembers(@NotNull JetType type) { + public static List getAbstractMembers(@NotNull JetType type) { List abstractMembers = Lists.newArrayList(); for (DeclarationDescriptor member : type.getMemberScope().getAllDescriptors()) { if (member instanceof CallableMemberDescriptor && diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.java b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.java new file mode 100644 index 00000000000..0585609ad95 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.java @@ -0,0 +1,6 @@ +package test; + +import java.util.Comparator; + +public interface SubstitutedSamInterface extends Comparator { +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.txt b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.txt new file mode 100644 index 00000000000..d292208116a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.txt @@ -0,0 +1,7 @@ +package test + +public /*synthesized*/ fun SubstitutedSamInterface(/*0*/ function: (jet.String?, jet.String?) -> jet.Int): test.SubstitutedSamInterface + +public trait SubstitutedSamInterface : java.util.Comparator { + public abstract override /*1*/ /*fake_override*/ fun compare(/*0*/ p0: jet.String?, /*1*/ p1: jet.String?): jet.Int +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.java b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.java new file mode 100644 index 00000000000..f60d884bf46 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.java @@ -0,0 +1,4 @@ +package test; + +public interface SubstitutedSamInterfaceSubclassOfBuiltin extends Comparable { +} diff --git a/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.txt b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.txt new file mode 100644 index 00000000000..cd1b36fa97e --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.txt @@ -0,0 +1,7 @@ +package test + +public /*synthesized*/ fun SubstitutedSamInterfaceSubclassOfBuiltin(/*0*/ function: (test.SubstitutedSamInterfaceSubclassOfBuiltin) -> jet.Int): test.SubstitutedSamInterfaceSubclassOfBuiltin + +public trait SubstitutedSamInterfaceSubclassOfBuiltin : jet.Comparable { + public abstract override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.SubstitutedSamInterfaceSubclassOfBuiltin): jet.Int +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index 6506c2d5255..5d88070a54a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -1218,6 +1218,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/Runnable.java"); } + @TestMetadata("SubstitutedSamInterface.java") + public void testSubstitutedSamInterface() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterface.java"); + } + + @TestMetadata("SubstitutedSamInterfaceSubclassOfBuiltin.java") + public void testSubstitutedSamInterfaceSubclassOfBuiltin() throws Exception { + doTestCompiledJava("compiler/testData/loadJava/compiledJava/singleAbstractMethod/SubstitutedSamInterfaceSubclassOfBuiltin.java"); + } + @TestMetadata("compiler/testData/loadJava/compiledJava/singleAbstractMethod/adapter") public static class Adapter extends AbstractLoadJavaTest { public void testAllFilesPresentInAdapter() throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index 4c683e969e2..b2bcdbb32bf 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -130,6 +130,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/class/InheritClassWithParam.kt"); } + @TestMetadata("InheritSubstitutedMethod.kt") + public void testInheritSubstitutedMethod() throws Exception { + doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/class/InheritSubstitutedMethod.kt"); + } + @TestMetadata("InheritTraitWithParam.kt") public void testInheritTraitWithParam() throws Exception { doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/class/InheritTraitWithParam.kt"); From 43b9a9d434a638aeaaa058f772efd3db5617cfd2 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 17:56:04 +0400 Subject: [PATCH 30/92] Renamed Name.getName() and FqName.getFqName() to asString() --- .../jet/codegen/AnnotationCodegen.java | 6 +-- .../org/jetbrains/jet/codegen/AsmUtil.java | 6 +-- .../jetbrains/jet/codegen/ClosureCodegen.java | 8 ++-- .../jet/codegen/ExpressionCodegen.java | 16 +++---- .../org/jetbrains/jet/codegen/FieldInfo.java | 2 +- .../jet/codegen/FunctionCodegen.java | 6 +-- .../codegen/ImplementationBodyCodegen.java | 12 ++--- .../jet/codegen/PropertyCodegen.java | 10 ++-- .../jet/codegen/RangeCodegenUtil.java | 2 +- .../org/jetbrains/jet/codegen/StackValue.java | 2 +- .../binding/CodegenAnnotatingVisitor.java | 4 +- .../codegen/binding/PsiCodegenPredictor.java | 10 ++-- .../codegen/intrinsics/IntrinsicMethods.java | 2 +- .../jet/codegen/intrinsics/StaticField.java | 2 +- .../signature/BothSignatureWriter.java | 4 +- .../jet/codegen/state/JetTypeMapper.java | 8 ++-- .../messages/AnalyzerWithCompilerReport.java | 2 +- .../jvm/compiler/CompileEnvironmentUtil.java | 2 +- .../jet/cli/jvm/repl/ReplInterpreter.java | 2 +- .../resolve/java/DescriptorResolverUtils.java | 2 +- .../resolve/java/JavaToKotlinClassMap.java | 4 +- .../resolve/java/JavaTypeTransformer.java | 6 +-- .../java/JetTypeJetSignatureReader.java | 2 +- .../jet/lang/resolve/java/JvmAbi.java | 4 +- .../jet/lang/resolve/java/JvmClassName.java | 4 +- .../resolve/java/KotlinToJavaTypesMap.java | 2 +- .../lang/resolve/java/PackageClassUtils.java | 2 +- .../lang/resolve/java/PsiClassFinderImpl.java | 6 +-- ...peVariableResolverFromTypeDescriptors.java | 2 +- .../SignaturesPropagationData.java | 2 +- .../TypeTransformingVisitor.java | 6 +-- .../resolve/java/kt/JetClassAnnotation.java | 2 +- .../java/kt/JetClassObjectAnnotation.java | 2 +- .../java/kt/JetConstructorAnnotation.java | 2 +- .../resolve/java/kt/JetMethodAnnotation.java | 2 +- .../java/kt/JetPackageClassAnnotation.java | 2 +- .../java/kt/JetTypeParameterAnnotation.java | 2 +- .../java/kt/JetValueParameterAnnotation.java | 2 +- .../java/kt/KotlinSignatureAnnotation.java | 2 +- .../resolve/java/provider/MembersCache.java | 2 +- .../java/resolver/JavaAnnotationResolver.java | 2 +- .../resolver/JavaClassObjectResolver.java | 2 +- .../java/resolver/JavaClassResolver.java | 7 ++- .../java/resolver/JavaFunctionResolver.java | 4 +- .../java/resolver/JavaPropertyResolver.java | 2 +- .../resolver/JavaValueParameterResolver.java | 2 +- .../descriptors/impl/ClassDescriptorImpl.java | 2 +- .../impl/MutableClassDescriptorLite.java | 2 +- .../impl/TypeParameterDescriptorImpl.java | 2 +- .../lang/diagnostics/rendering/Renderers.java | 4 +- .../org/jetbrains/jet/lang/psi/JetClass.java | 2 +- .../jetbrains/jet/lang/psi/JetPsiFactory.java | 2 +- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 4 +- .../elements/JetAnnotationElementType.java | 2 +- .../stubs/elements/JetClassElementType.java | 4 +- .../jet/lang/resolve/AnnotationResolver.java | 4 +- .../jet/lang/resolve/DeclarationResolver.java | 4 +- .../jet/lang/resolve/DeclarationsChecker.java | 2 +- .../jet/lang/resolve/DescriptorUtils.java | 8 ++-- .../jet/lang/resolve/ImportPath.java | 4 +- .../jet/lang/resolve/OverloadResolver.java | 6 +-- .../jet/lang/resolve/OverrideResolver.java | 4 +- .../TraceBasedRedeclarationHandler.java | 2 +- .../jet/lang/resolve/TypeResolver.java | 2 +- .../jet/lang/resolve/calls/CallResolver.java | 3 +- .../calls/tasks/TracingStrategyImpl.java | 2 +- .../descriptors/LazyClassMemberScope.java | 2 +- .../jet/lang/resolve/name/FqName.java | 6 +-- .../jet/lang/resolve/name/FqNameBase.java | 4 +- .../jet/lang/resolve/name/FqNameUnsafe.java | 14 +++--- .../jetbrains/jet/lang/resolve/name/Name.java | 4 +- .../resolve/scopes/WritableScopeImpl.java | 4 +- .../BasicExpressionTypingVisitor.java | 4 +- .../ControlStructureTypingVisitor.java | 2 +- .../expressions/DelegatedPropertyUtils.java | 4 +- .../expressions/ExpressionTypingUtils.java | 4 +- .../jet/lang/types/lang/KotlinBuiltIns.java | 8 ++-- .../jet/util/QualifiedNamesUtil.java | 12 ++--- .../jetbrains/jet/asJava/JetLightPackage.java | 2 +- .../asJava/KotlinJavaFileStubProvider.java | 4 +- ...otlinLightClassForExplicitDeclaration.java | 10 ++-- .../asJava/KotlinLightClassForPackage.java | 4 +- .../jetbrains/jet/asJava/LightClassUtil.java | 4 +- .../tests/org/jetbrains/jet/FqNameTest.java | 46 +++++++++---------- .../jet/codegen/CodegenTestCase.java | 2 +- .../AbstractBlackBoxCodegenTest.java | 2 +- .../AbstractLoadCompiledKotlinTest.java | 2 +- .../jvm/compiler/ExpectedLoadErrorsUtil.java | 3 +- .../IdeaJdkAnnotationsReflectedTest.java | 4 +- .../jet/jvm/compiler/JvmClassNameTest.java | 4 +- .../jet/test/util/NamespaceComparator.java | 2 +- .../jvm/GenerateJavaToKotlinMethodMap.java | 4 +- .../jetbrains/jet/plugin/JetPluginUtil.java | 4 +- .../plugin/actions/JetAddImportAction.java | 4 +- .../caches/JetGotoClassContributor.java | 2 +- .../jet/plugin/caches/JetShortNamesCache.java | 14 +++--- .../IDELightClassGenerationSupport.java | 14 +++--- .../ReferenceToClassesShortening.java | 2 +- .../ktSignature/KotlinSignatureUtil.java | 2 +- .../completion/DescriptorLookupConverter.java | 4 +- .../importOptimizer/JetImportOptimizer.java | 2 +- .../DeprecatedAnnotationVisitor.java | 2 +- .../jet/plugin/highlighter/IdeRenderers.java | 2 +- .../libraries/JetSourceNavigationHelper.java | 8 ++-- .../jet/plugin/libraries/MemberMatching.java | 4 +- .../quickfix/AddFunctionParametersFix.java | 6 +-- .../plugin/quickfix/AddNameToArgumentFix.java | 4 +- .../jet/plugin/quickfix/AutoImportFix.java | 2 +- .../quickfix/ChangeFunctionReturnTypeFix.java | 5 +- .../plugin/quickfix/ImportInsertHelper.java | 4 +- .../quickfix/MakeOverriddenMemberOpenFix.java | 2 +- .../quickfix/MapPlatformClassToKotlinFix.java | 4 +- .../quickfix/RemoveFunctionParametersFix.java | 2 +- ...meParameterToMatchOverriddenMethodFix.java | 4 +- .../plugin/refactoring/JetNameSuggester.java | 4 +- .../refactoring/JetNameValidatorImpl.java | 2 +- .../changeSignature/JetChangeInfo.java | 2 +- .../JetFunctionPlatformDescriptorImpl.java | 6 +-- .../run/JetRunConfigurationProducer.java | 6 +-- .../KotlinAnnotatedElementsSearcher.java | 2 +- .../KotlinDirectInheritorsSearcher.java | 2 +- .../JetStructureViewElement.java | 4 +- .../stubindex/StubIndexServiceImpl.java | 10 ++-- .../versions/KotlinRuntimeLibraryUtil.java | 2 +- .../codeInsight/OverrideImplementTest.java | 2 +- .../NavigateToStdlibSourceRegressionTest.java | 4 +- .../BuiltInsReferenceResolverTest.java | 2 +- .../jet/j2k/visitors/TypeVisitor.java | 2 +- .../k2js/translate/context/Namer.java | 2 +- .../k2js/translate/context/StaticContext.java | 10 ++-- .../translate/context/TranslationContext.java | 2 +- .../expression/StringTemplateTranslator.java | 4 +- .../foreach/ArrayForTranslator.java | 4 +- .../foreach/RangeForTranslator.java | 2 +- .../initializer/InitializerUtils.java | 4 +- .../PrimitiveBinaryOperationFIF.java | 4 +- .../factories/PrimitiveUnaryOperationFIF.java | 2 +- .../functions/patterns/NamePredicate.java | 2 +- .../translate/reference/CallTranslator.java | 2 +- .../translate/utils/AnnotationsUtils.java | 2 +- 140 files changed, 294 insertions(+), 304 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java index 87fb2949e3c..b8ac58e8cc4 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java @@ -115,7 +115,7 @@ public abstract class AnnotationCodegen { } Name keyName = entry.getKey().getName(); - genAnnotationValueArgument(annotationVisitor, valueArgument, keyName.getName()); + genAnnotationValueArgument(annotationVisitor, valueArgument, keyName.asString()); } } @@ -152,7 +152,7 @@ public abstract class AnnotationCodegen { if (call != null) { if (call.getResultingDescriptor() instanceof PropertyDescriptor) { PropertyDescriptor descriptor = (PropertyDescriptor) call.getResultingDescriptor(); - annotationVisitor.visitEnum(keyName, typeMapper.mapType(descriptor).getDescriptor(), descriptor.getName().getName()); + annotationVisitor.visitEnum(keyName, typeMapper.mapType(descriptor).getDescriptor(), descriptor.getName().asString()); return; } } @@ -168,7 +168,7 @@ public abstract class AnnotationCodegen { if (annotations != null) { for (AnnotationDescriptor annotation : annotations) { //noinspection ConstantConditions - if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().getName())) { + if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().asString())) { value = (String) annotation.getAllValueArguments().values().iterator().next().getValue(); break; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 4596c51c4c5..76d717a323b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -505,7 +505,7 @@ public class AsmUtil { Type asmType = state.getTypeMapper().mapReturnType(type); if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) { v.load(index, asmType); - v.visitLdcInsn(descriptor.getName().getName()); + v.visitLdcInsn(descriptor.getName().asString()); v.invokestatic("jet/runtime/Intrinsics", "checkParameterIsNotNull", "(Ljava/lang/Object;Ljava/lang/String;)V"); } } @@ -546,8 +546,8 @@ public class AsmUtil { Type asmType = state.getTypeMapper().mapReturnType(type); if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) { v.dup(); - v.visitLdcInsn(descriptor.getContainingDeclaration().getName().getName()); - v.visitLdcInsn(descriptor.getName().getName()); + v.visitLdcInsn(descriptor.getContainingDeclaration().getName().asString()); + v.visitLdcInsn(descriptor.getName().asString()); v.invokestatic("jet/runtime/Intrinsics", assertMethodToCall, "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V"); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java index d53c617333b..ea860a0a78c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -178,7 +178,7 @@ public class ClosureCodegen extends GenerationStateAware { return; } - MethodVisitor mv = cv.newMethod(fun, ACC_PUBLIC | ACC_BRIDGE, interfaceFunction.getName().getName(), + MethodVisitor mv = cv.newMethod(fun, ACC_PUBLIC | ACC_BRIDGE, interfaceFunction.getName().asString(), bridge.getDescriptor(), null, ArrayUtil.EMPTY_STRING_ARRAY); if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) { genStubCode(mv); @@ -203,7 +203,7 @@ public class ClosureCodegen extends GenerationStateAware { count++; } - iv.invokevirtual(name.getInternalName(), interfaceFunction.getName().getName(), delegate.getDescriptor()); + iv.invokevirtual(name.getInternalName(), interfaceFunction.getName().asString(), delegate.getDescriptor()); StackValue.onStack(delegate.getReturnType()).put(bridge.getReturnType(), iv); iv.areturn(bridge.getReturnType()); @@ -268,11 +268,11 @@ public class ClosureCodegen extends GenerationStateAware { Type type = sharedVarType != null ? sharedVarType : typeMapper.mapType((VariableDescriptor) descriptor); - args.add(FieldInfo.createForHiddenField(ownerType, type, "$" + descriptor.getName().getName())); + args.add(FieldInfo.createForHiddenField(ownerType, type, "$" + descriptor.getName().asString())); } else if (isLocalNamedFun(descriptor)) { JvmClassName className = classNameForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor); - args.add(FieldInfo.createForHiddenField(ownerType, className.getAsmType(), "$" + descriptor.getName().getName())); + args.add(FieldInfo.createForHiddenField(ownerType, className.getAsmType(), "$" + descriptor.getName().asString())); } else if (descriptor instanceof FunctionDescriptor) { assert captureReceiver != null; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 093ac725a21..adb1cf703f6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -560,7 +560,7 @@ public class ExpressionCodegen extends JetVisitor implem @Override public void run() { myFrameMap.leave(parameterDescriptor); - v.visitLocalVariable(parameterDescriptor.getName().getName(), + v.visitLocalVariable(parameterDescriptor.getName().asString(), asmTypeForParameter.getDescriptor(), null, bodyStart, bodyEnd, loopParameterVar); @@ -601,7 +601,7 @@ public class ExpressionCodegen extends JetVisitor implem @Override public void run() { myFrameMap.leave(componentDescriptor); - v.visitLocalVariable(componentDescriptor.getName().getName(), + v.visitLocalVariable(componentDescriptor.getName().asString(), componentAsmType.getDescriptor(), null, bodyStart, bodyEnd, componentVarIndex); @@ -1414,7 +1414,7 @@ public class ExpressionCodegen extends JetVisitor implem v.store(index, OBJECT_TYPE); } } - v.visitLocalVariable(variableDescriptor.getName().getName(), type.getDescriptor(), null, scopeStart, blockEnd, + v.visitLocalVariable(variableDescriptor.getName().asString(), type.getDescriptor(), null, scopeStart, blockEnd, index); return null; } @@ -1628,7 +1628,7 @@ public class ExpressionCodegen extends JetVisitor implem ClassDescriptor containing = (ClassDescriptor) variableDescriptor.getContainingDeclaration().getContainingDeclaration(); assert containing != null; Type type = typeMapper.mapType(containing); - return StackValue.field(type, JvmClassName.byType(type), variableDescriptor.getName().getName(), true); + return StackValue.field(type, JvmClassName.byType(type), variableDescriptor.getName().asString(), true); } else { return StackValue.singleton(objectClassDescriptor, typeMapper); @@ -2924,7 +2924,7 @@ public class ExpressionCodegen extends JetVisitor implem else { DeclarationDescriptor cls = op.getContainingDeclaration(); CallableMethod callableMethod = (CallableMethod) callable; - if (isPrimitiveNumberClassDescriptor(cls) || !(op.getName().getName().equals("inc") || op.getName().getName().equals("dec"))) { + if (isPrimitiveNumberClassDescriptor(cls) || !(op.getName().asString().equals("inc") || op.getName().asString().equals("dec"))) { return invokeOperation(expression, (FunctionDescriptor) op, callableMethod); } else { @@ -2981,14 +2981,14 @@ public class ExpressionCodegen extends JetVisitor implem if (op instanceof FunctionDescriptor) { Type asmType = expressionType(expression); DeclarationDescriptor cls = op.getContainingDeclaration(); - if (op.getName().getName().equals("inc") || op.getName().getName().equals("dec")) { + if (op.getName().asString().equals("inc") || op.getName().asString().equals("dec")) { if (isPrimitiveNumberClassDescriptor(cls)) { receiver.put(receiver.type, v); JetExpression operand = expression.getBaseExpression(); if (operand instanceof JetReferenceExpression) { int index = indexOfLocal((JetReferenceExpression) operand); if (index >= 0 && isIntPrimitive(asmType)) { - int increment = op.getName().getName().equals("inc") ? 1 : -1; + int increment = op.getName().asString().equals("inc") ? 1 : -1; return StackValue.postIncrement(index, increment); } } @@ -3053,7 +3053,7 @@ public class ExpressionCodegen extends JetVisitor implem } private void generateIncrement(DeclarationDescriptor op, Type asmType, JetExpression operand, StackValue receiver) { - int increment = op.getName().getName().equals("inc") ? 1 : -1; + int increment = op.getName().asString().equals("inc") ? 1 : -1; if (operand instanceof JetReferenceExpression) { int index = indexOfLocal((JetReferenceExpression) operand); if (index >= 0 && isIntPrimitive(asmType)) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FieldInfo.java b/compiler/backend/src/org/jetbrains/jet/codegen/FieldInfo.java index 47371252938..6cafb4a834c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FieldInfo.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FieldInfo.java @@ -41,7 +41,7 @@ public class FieldInfo { Type ownerType = typeMapper.mapType(ownerDescriptor.getDefaultType()); String fieldName = kind == ClassKind.ENUM_ENTRY - ? fieldClassDescriptor.getName().getName() + ? fieldClassDescriptor.getName().asString() : fieldClassDescriptor.getKind() == ClassKind.CLASS_OBJECT ? JvmAbi.CLASS_OBJECT_FIELD : JvmAbi.INSTANCE_FIELD; return new FieldInfo(ownerType, fieldType, fieldName, true); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 5c99197b3c6..ccbff63900f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -200,7 +200,7 @@ public class FunctionCodegen extends GenerationStateAware { List parameters = functionDescriptor.getValueParameters(); List result = new ArrayList(parameters.size()); for (ValueParameterDescriptor parameter : parameters) { - result.add(parameter.getName().getName()); + result.add(parameter.getName().asString()); } return result; } @@ -244,7 +244,7 @@ public class FunctionCodegen extends GenerationStateAware { if (kind == JvmMethodParameterKind.VALUE) { ValueParameterDescriptor parameter = valueParameters.next(); Label divideLabel = labelsForSharedVars.get(parameter.getName()); - parameterName = parameter.getName().getName(); + parameterName = parameter.getName().asString(); if (divideLabel != null) { mv.visitLocalVariable(parameterName, type.getDescriptor(), null, methodBegin, divideLabel, shift); @@ -377,7 +377,7 @@ public class FunctionCodegen extends GenerationStateAware { ValueParameterDescriptor parameterDescriptor = null; if (kind == JvmMethodParameterKind.VALUE) { parameterDescriptor = valueParameters.next(); - parameterName = parameterDescriptor.getName().getName(); + parameterName = parameterDescriptor.getName().asString(); } else if (kind == JvmMethodParameterKind.ENUM_NAME || kind == JvmMethodParameterKind.ENUM_ORDINAL) { //we shouldn't generate annotations for invisible in runtime parameters otherwise we get bad RuntimeInvisibleParameterAnnotations error in javac continue; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index cba0dfea6d1..785d3a0913e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -297,7 +297,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { innerClassInternalName = outerClassInternalName + JvmAbi.CLASS_OBJECT_SUFFIX; } else { - innerName = innerClass.getName().isSpecial() ? null : innerClass.getName().getName(); + innerName = innerClass.getName().isSpecial() ? null : innerClass.getName().asString(); innerClassInternalName = getInternalNameForImpl(innerClass); } @@ -620,11 +620,11 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { boolean first = true; for (PropertyDescriptor propertyDescriptor : properties) { if (first) { - iv.aconst(descriptor.getName() + "(" + propertyDescriptor.getName().getName()+"="); + iv.aconst(descriptor.getName() + "(" + propertyDescriptor.getName().asString()+"="); first = false; } else { - iv.aconst(", " + propertyDescriptor.getName().getName()+"="); + iv.aconst(", " + propertyDescriptor.getName().asString()+"="); } genInvokeAppendMethod(iv, JAVA_STRING_TYPE); @@ -821,7 +821,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Type[] argTypes = method.getArgumentTypes(); String owner = typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION, isCallInsideSameModuleAsDeclared(original, context)).getInternalName(); - MethodVisitor mv = v.newMethod(null, ACC_SYNTHETIC | ACC_STATIC, bridge.getName().getName(), + MethodVisitor mv = v.newMethod(null, ACC_SYNTHETIC | ACC_STATIC, bridge.getName().asString(), method.getDescriptor(), null, null); if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) { genStubCode(mv); @@ -1015,7 +1015,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Type type = typeMapper.mapType(descriptor); iv.load(0, classAsmType); iv.load(codegen.myFrameMap.getIndex(descriptor), type); - iv.putfield(classAsmType.getInternalName(), descriptor.getName().getName(), type.getDescriptor()); + iv.putfield(classAsmType.getInternalName(), descriptor.getName().asString(), type.getDescriptor()); } curParam++; } @@ -1097,7 +1097,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor))) { // final property with backing field field = StackValue.field(typeMapper.mapType(propertyDescriptor.getType()), classname, - propertyDescriptor.getName().getName(), false); + propertyDescriptor.getName().asString(), false); } else { iv.load(0, classType); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 10a7bee673e..34c71c9655b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -148,7 +148,7 @@ public class PropertyCodegen extends GenerationStateAware { modifiers |= ACC_VOLATILE; } Type type = typeMapper.mapType(propertyDescriptor); - return v.newField(p, modifiers, propertyDescriptor.getName().getName(), type.getDescriptor(), null, value); + return v.newField(p, modifiers, propertyDescriptor.getName().asString(), type.getDescriptor(), null, value); } private void generateGetter(JetNamedDeclaration p, PropertyDescriptor propertyDescriptor, JetPropertyAccessor getter) { @@ -248,7 +248,7 @@ public class PropertyCodegen extends GenerationStateAware { iv.visitFieldInsn( kind == OwnerKind.NAMESPACE ? GETSTATIC : GETFIELD, typeMapper.getOwner(propertyDescriptor, kind, isCallInsideSameModuleAsDeclared(propertyDescriptor, context)).getInternalName(), - propertyDescriptor.getName().getName(), + propertyDescriptor.getName().asString(), type.getDescriptor()); iv.areturn(type); } @@ -265,7 +265,7 @@ public class PropertyCodegen extends GenerationStateAware { iv.load(paramCode, type); iv.visitFieldInsn(kind == OwnerKind.NAMESPACE ? PUTSTATIC : PUTFIELD, typeMapper.getOwner(propertyDescriptor, kind, isCallInsideSameModuleAsDeclared(propertyDescriptor, context)).getInternalName(), - propertyDescriptor.getName().getName(), + propertyDescriptor.getName().asString(), type.getDescriptor()); iv.visitInsn(RETURN); @@ -336,11 +336,11 @@ public class PropertyCodegen extends GenerationStateAware { } public static String getterName(Name propertyName) { - return JvmAbi.GETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.getName()); + return JvmAbi.GETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString()); } public static String setterName(Name propertyName) { - return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.getName()); + return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString()); } public void genDelegate(PropertyDescriptor delegate, PropertyDescriptor overridden, StackValue field) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/RangeCodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/RangeCodegenUtil.java index 17f5409bc3e..ebb6ad902e0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/RangeCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/RangeCodegenUtil.java @@ -112,7 +112,7 @@ public class RangeCodegenUtil { } public static boolean isOptimizableRangeTo(CallableDescriptor rangeTo) { - if ("rangeTo".equals(rangeTo.getName().getName())) { + if ("rangeTo".equals(rangeTo.getName().asString())) { if (isPrimitiveNumberClassDescriptor(rangeTo.getContainingDeclaration())) { return true; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java index 3fcaae8c1ff..b7f8d673b7d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java @@ -913,7 +913,7 @@ public abstract class StackValue { } private String getPropertyName() { - return isDelegated ? JvmAbi.getPropertyDelegateName(descriptor.getName()) : descriptor.getName().getName(); + return isDelegated ? JvmAbi.getPropertyDelegateName(descriptor.getName()) : descriptor.getName().asString(); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java index 05f737656ab..b91bf08e7d7 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java @@ -227,7 +227,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid { private String getName(ClassDescriptor classDescriptor) { String base = peekFromStack(nameStack); return DescriptorUtils.isTopLevelDeclaration(classDescriptor) ? base.isEmpty() ? classDescriptor.getName() - .getName() : base + '/' + classDescriptor.getName() : base + '$' + classDescriptor.getName(); + .asString() : base + '/' + classDescriptor.getName() : base + '$' + classDescriptor.getName(); } @Override @@ -350,7 +350,7 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); String peek = peekFromStack(nameStack); - String name = descriptor.getName().getName(); + String name = descriptor.getName().asString(); if (containingDeclaration instanceof ClassDescriptor) { return peek + '$' + name; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java index 4946194d635..b3affd8f237 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/PsiCodegenPredictor.java @@ -116,7 +116,7 @@ public final class PsiCodegenPredictor { if (declaration instanceof JetNamedFunction) { if (parentDeclaration == null) { JvmClassName packageClass = addPackageClass(parentClassName); - return JvmClassName.byInternalName(packageClass.getInternalName() + "$" + name.getName()); + return JvmClassName.byInternalName(packageClass.getInternalName() + "$" + name.asString()); } if (!(parentDeclaration instanceof JetClass || parentDeclaration instanceof JetObjectDeclaration)) { @@ -128,16 +128,16 @@ public final class PsiCodegenPredictor { // NOTE: looks like a bug - for class in getter of top level property class name will be $propertyName$ClassName but not // namespace$propertyName$ClassName if (declaration instanceof JetProperty) { - return JvmClassName.byInternalName(parentClassName.getInternalName() + "$" + name.getName()); + return JvmClassName.byInternalName(parentClassName.getInternalName() + "$" + name.asString()); } if (fqName.isRoot()) { - return JvmClassName.byInternalName(name.getName()); + return JvmClassName.byInternalName(name.asString()); } return JvmClassName.byInternalName(parentDeclaration == null ? - parentClassName.getInternalName() + "/" + name.getName() : - parentClassName.getInternalName() + "$" + name.getName()); + parentClassName.getInternalName() + "/" + name.asString() : + parentClassName.getInternalName() + "$" + name.asString()); } return null; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index d82fa7073c0..69b4a44be93 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -241,7 +241,7 @@ public class IntrinsicMethods { for (AnnotationDescriptor annotation : annotations) { ClassifierDescriptor classifierDescriptor = annotation.getType().getConstructor().getDeclarationDescriptor(); assert classifierDescriptor != null; - if ("Intrinsic".equals(classifierDescriptor.getName().getName())) { + if ("Intrinsic".equals(classifierDescriptor.getName().asString())) { String value = (String) annotation.getAllValueArguments().values().iterator().next().getValue(); intrinsicMethod = namedMethods.get(value); if (intrinsicMethod != null) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StaticField.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StaticField.java index 6339aeaaf21..034e0ba3f85 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StaticField.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StaticField.java @@ -51,7 +51,7 @@ public class StaticField implements IntrinsicMethod { StackValue receiver, @NotNull GenerationState state ) { - v.getstatic(JvmClassName.byFqNameWithoutInnerClasses(ownerClass).getInternalName(), propertyName.getName(), expectedType.getDescriptor()); + v.getstatic(JvmClassName.byFqNameWithoutInnerClasses(ownerClass).getInternalName(), propertyName.asString(), expectedType.getDescriptor()); return StackValue.onStack(expectedType); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java b/compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java index bf733044928..de3de631c4e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java @@ -272,8 +272,8 @@ public class BothSignatureWriter { } public void writeTypeVariable(Name name, boolean nullable, Type asmType) { - signatureVisitor().visitTypeVariable(name.getName()); - jetSignatureWriter.visitTypeVariable(name.getName(), nullable); + signatureVisitor().visitTypeVariable(name.asString()); + jetSignatureWriter.visitTypeVariable(name.asString(), nullable); generic = true; writeAsmType0(asmType); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 6b2e915f340..d9606affaf0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -578,7 +578,7 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull public JvmMethodSignature mapSignature(@NotNull FunctionDescriptor f, boolean needGenericSignature, @NotNull OwnerKind kind) { - String name = f.getName().getName(); + String name = f.getName().asString(); if (f instanceof PropertyAccessorDescriptor) { boolean isGetter = f instanceof PropertyGetterDescriptor; name = getPropertyAccessorName(((PropertyAccessorDescriptor) f).getCorrespondingProperty(), isGetter); @@ -588,7 +588,7 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull public JvmMethodSignature mapSignature(@NotNull Name functionName, @NotNull FunctionDescriptor f) { - return mapSignature(functionName.getName(), f, false, OwnerKind.IMPLEMENTATION); + return mapSignature(functionName.asString(), f, false, OwnerKind.IMPLEMENTATION); } @NotNull @@ -675,7 +675,7 @@ public class JetTypeMapper extends BindingTraceAware { } private void writeFormalTypeParameter(TypeParameterDescriptor typeParameterDescriptor, BothSignatureWriter signatureVisitor) { - signatureVisitor.writeFormalTypeParameter(typeParameterDescriptor.getName().getName(), typeParameterDescriptor.getVariance(), + signatureVisitor.writeFormalTypeParameter(typeParameterDescriptor.getName().asString(), typeParameterDescriptor.getVariance(), typeParameterDescriptor.isReified()); classBound: @@ -730,7 +730,7 @@ public class JetTypeMapper extends BindingTraceAware { DeclarationDescriptor parentDescriptor = descriptor.getContainingDeclaration(); boolean isAnnotation = parentDescriptor instanceof ClassDescriptor && ((ClassDescriptor) parentDescriptor).getKind() == ClassKind.ANNOTATION_CLASS; - return isAnnotation ? descriptor.getName().getName() : + return isAnnotation ? descriptor.getName().asString() : isGetter ? PropertyCodegen.getterName(descriptor.getName()) : PropertyCodegen.setterName(descriptor.getName()); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java index 444d44fed95..6e6092088cd 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java @@ -109,7 +109,7 @@ public final class AnalyzerWithCompilerReport { if (!incompletes.isEmpty()) { StringBuilder message = new StringBuilder("The following classes have incomplete hierarchies:\n"); for (ClassDescriptor incomplete : incompletes) { - String fqName = DescriptorUtils.getFQName(incomplete).getFqName(); + String fqName = DescriptorUtils.getFQName(incomplete).asString(); message.append(" ").append(fqName).append("\n"); } messageCollectorWrapper.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java index 48f3f83464d..e8ccfee3774 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -203,7 +203,7 @@ public class CompileEnvironmentUtil { mainAttributes.putValue("Manifest-Version", "1.0"); mainAttributes.putValue("Created-By", "JetBrains Kotlin"); if (mainClass != null) { - mainAttributes.putValue("Main-Class", mainClass.getFqName()); + mainAttributes.putValue("Main-Class", mainClass.asString()); } JarOutputStream stream = new JarOutputStream(fos, manifest); for (String file : factory.files()) { diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index cbade7676cc..89eae3219e7 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -236,7 +236,7 @@ public class ReplInterpreter { } try { - Class scriptClass = classLoader.loadClass(scriptClassName.getFqName().getFqName()); + Class scriptClass = classLoader.loadClass(scriptClassName.getFqName().asString()); Class[] constructorParams = new Class[earlierLines.size()]; Object[] constructorArgs = new Object[earlierLines.size()]; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index 0fca6080224..c81e4fad3bb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -140,7 +140,7 @@ public final class DescriptorResolverUtils { public static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) { String psiClassQualifiedName = psiClass.getQualifiedName(); assert psiClassQualifiedName != null : "Reading java class with no qualified name"; - return new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).getName()); + return new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).asString()); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java index ef9da4ac6ab..5de6852d9a6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java @@ -65,7 +65,7 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); primitiveTypesMap.put(jvmPrimitiveType.getName(), KotlinBuiltIns.getInstance().getPrimitiveJetType(primitiveType)); primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), KotlinBuiltIns.getInstance().getPrimitiveArrayJetType(primitiveType)); - primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().getFqName(), KotlinBuiltIns.getInstance().getNullablePrimitiveJetType( + primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().asString(), KotlinBuiltIns.getInstance().getNullablePrimitiveJetType( primitiveType)); } primitiveTypesMap.put("void", KotlinBuiltIns.getInstance().getUnitType()); @@ -91,7 +91,7 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements @Nullable public AnnotationDescriptor mapToAnnotationClass(@NotNull FqName fqName) { ClassDescriptor classDescriptor = classDescriptorMap.get(fqName); - if (classDescriptor != null && fqName.getFqName().equals(CommonClassNames.JAVA_LANG_DEPRECATED)) { + if (classDescriptor != null && fqName.asString().equals(CommonClassNames.JAVA_LANG_DEPRECATED)) { return DescriptorResolverUtils.getAnnotationDescriptorForJavaLangDeprecated(classDescriptor); } return null; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index 5c30676b45a..3e7255de471 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -184,7 +184,7 @@ public class JavaTypeTransformer { " in " + classType.getPresentableText() + "\n PsiClass: \n" + psiClass.getText()); for (TypeParameterDescriptor parameter : parameters) { - arguments.add(new TypeProjection(ErrorUtils.createErrorType(parameter.getName().getName()))); + arguments.add(new TypeProjection(ErrorUtils.createErrorType(parameter.getName().asString()))); } } else { @@ -275,10 +275,10 @@ public class JavaTypeTransformer { if (!signatureTypeUsages.contains(originalTypeUsage)) { return originalTypeUsage; } - if (JavaAnnotationResolver.findAnnotationWithExternal(owner, JvmAbi.JETBRAINS_MUTABLE_ANNOTATION.getFqName().getFqName()) != null) { + if (JavaAnnotationResolver.findAnnotationWithExternal(owner, JvmAbi.JETBRAINS_MUTABLE_ANNOTATION.getFqName().asString()) != null) { return TypeUsage.MEMBER_SIGNATURE_COVARIANT; } - if (JavaAnnotationResolver.findAnnotationWithExternal(owner, JvmAbi.JETBRAINS_READONLY_ANNOTATION.getFqName().getFqName()) != null) { + if (JavaAnnotationResolver.findAnnotationWithExternal(owner, JvmAbi.JETBRAINS_READONLY_ANNOTATION.getFqName().asString()) != null) { return TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT; } return originalTypeUsage; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index eeb44f1d4b0..f0f02b821c1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -86,7 +86,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd public void visitClassType(String signatureName, boolean nullable, boolean forceReal) { FqName fqName = JvmClassName.bySignatureName(signatureName).getFqName(); - enterClass(resolveClassDescriptorByFqName(fqName, forceReal), fqName.getFqName(), nullable); + enterClass(resolveClassDescriptorByFqName(fqName, forceReal), fqName.asString(), nullable); } private void enterClass(@Nullable ClassDescriptor classDescriptor, @NotNull String className, boolean nullable) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java index 087c8a9b6b4..aa592f4dd02 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java @@ -17,8 +17,6 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -58,7 +56,7 @@ public class JvmAbi { } public static String getPropertyDelegateName(@NotNull Name name) { - return name.getName() + DELEGATED_PROPERTY_NAME_POSTFIX; + return name.asString() + DELEGATED_PROPERTY_NAME_POSTFIX; } private JvmAbi() { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java index 4f54eff8e42..4ea57d3534e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java @@ -91,7 +91,7 @@ public class JvmClassName { List innerClassNames = Lists.newArrayList(); while (descriptor.getContainingDeclaration() instanceof ClassDescriptor) { - innerClassNames.add(descriptor.getName().getName()); + innerClassNames.add(descriptor.getName().asString()); descriptor = descriptor.getContainingDeclaration(); assert descriptor != null; } @@ -101,7 +101,7 @@ public class JvmClassName { @NotNull private static String fqNameToInternalName(@NotNull FqName fqName) { - return fqName.getFqName().replace('.', '/'); + return fqName.asString().replace('.', '/'); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/KotlinToJavaTypesMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/KotlinToJavaTypesMap.java index 2b337dc5ef9..b53096d39aa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/KotlinToJavaTypesMap.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/KotlinToJavaTypesMap.java @@ -122,6 +122,6 @@ public class KotlinToJavaTypesMap extends JavaToKotlinClassMapBuilder { public boolean isForceReal(@NotNull JvmClassName className) { return JvmPrimitiveType.getByWrapperClass(className) != null - || mappedTypeNames.contains(className.getFqName().getFqName()); + || mappedTypeNames.contains(className.getFqName().asString()); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java index c2c4e37250c..a268623bc4b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PackageClassUtils.java @@ -32,7 +32,7 @@ public class PackageClassUtils { if (packageFQN.isRoot()) { return DEFAULT_PACKAGE; } - return StringUtil.capitalize(packageFQN.shortName().getName()) + "Package"; + return StringUtil.capitalize(packageFQN.shortName().asString()) + "Package"; } public static FqName getPackageClassFqName(@NotNull FqName packageFQN) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderImpl.java index bee73db55a9..916d71fb48a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderImpl.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderImpl.java @@ -86,7 +86,7 @@ public class PsiClassFinderImpl implements PsiClassFinder { @Override @Nullable public PsiClass findPsiClass(@NotNull FqName qualifiedName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode) { - PsiClass original = javaFacade.findClass(qualifiedName.getFqName(), javaSearchScope); + PsiClass original = javaFacade.findClass(qualifiedName.asString(), javaSearchScope); if (original != null) { String classQualifiedName = original.getQualifiedName(); @@ -106,7 +106,7 @@ public class PsiClassFinderImpl implements PsiClassFinder { if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) { PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation( - original, JvmStdlibNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().getFqName()); + original, JvmStdlibNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString()); if (assertInvisibleAnnotation != null) { switch (runtimeClassesHandleMode) { @@ -131,7 +131,7 @@ public class PsiClassFinderImpl implements PsiClassFinder { @Override @Nullable public PsiPackage findPsiPackage(@NotNull FqName qualifiedName) { - return javaFacade.findPackage(qualifiedName.getFqName()); + return javaFacade.findPackage(qualifiedName.asString()); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java index 5a28fa68bb5..a8d75fd101b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeVariableResolverFromTypeDescriptors.java @@ -60,7 +60,7 @@ public class TypeVariableResolverFromTypeDescriptors implements TypeVariableReso @NotNull DeclarationDescriptor owner, @NotNull String context) { for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getName().getName().equals(name)) { + if (typeParameter.getName().asString().equals(name)) { return typeParameter; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java index 62b5993f9f3..55b59a76612 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java @@ -254,7 +254,7 @@ public class SignaturesPropagationData { public int compare(FunctionDescriptor fun1, FunctionDescriptor fun2) { FqNameUnsafe fqName1 = getFQName(fun1.getContainingDeclaration()); FqNameUnsafe fqName2 = getFQName(fun2.getContainingDeclaration()); - return fqName1.getFqName().compareTo(fqName2.getFqName()); + return fqName1.asString().compareTo(fqName2.asString()); } }); return superFunctions; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index 6ab3f537034..c100a35b698 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -99,14 +99,14 @@ public class TypeTransformingVisitor extends JetVisitor { } private JetType visitCommonType(@NotNull ClassDescriptor classDescriptor, @NotNull JetTypeElement type) { - return visitCommonType(DescriptorUtils.getFQName(classDescriptor).toSafe().getFqName(), type); + return visitCommonType(DescriptorUtils.getFQName(classDescriptor).toSafe().asString(), type); } private JetType visitCommonType(@NotNull String qualifiedName, @NotNull JetTypeElement type) { TypeConstructor originalTypeConstructor = originalType.getConstructor(); ClassifierDescriptor declarationDescriptor = originalTypeConstructor.getDeclarationDescriptor(); assert declarationDescriptor != null; - String fqName = DescriptorUtils.getFQName(declarationDescriptor).toSafe().getFqName(); + String fqName = DescriptorUtils.getFQName(declarationDescriptor).toSafe().asString(); ClassDescriptor classFromLibrary = getAutoTypeAnalogWithinBuiltins(qualifiedName); if (!isSameName(qualifiedName, fqName) && classFromLibrary == null) { throw new AlternativeSignatureMismatchException("Alternative signature type mismatch, expected: %s, actual: %s", qualifiedName, fqName); @@ -212,7 +212,7 @@ public class TypeTransformingVisitor extends JetVisitor { Collection descriptors = JavaToKotlinClassMap.getInstance().mapPlatformClass(JvmClassName.byType(javaAnalog).getFqName()); for (ClassDescriptor descriptor : descriptors) { - String fqName = DescriptorUtils.getFQName(descriptor).getFqName(); + String fqName = DescriptorUtils.getFQName(descriptor).asString(); if (isSameName(qualifiedName, fqName)) { return descriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassAnnotation.java index e7c1f3570cb..39fdb450eba 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassAnnotation.java @@ -54,7 +54,7 @@ public class JetClassAnnotation extends PsiAnnotationWithAbiVersion { @NotNull public static JetClassAnnotation get(PsiClass psiClass) { PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass, - JvmStdlibNames.JET_CLASS.getFqName().getFqName()); + JvmStdlibNames.JET_CLASS.getFqName().asString()); return annotation != null ? new JetClassAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java index bbebea1496e..c4a118d957d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetClassObjectAnnotation.java @@ -38,7 +38,7 @@ public class JetClassObjectAnnotation extends PsiAnnotationWithAbiVersion { @NotNull public static JetClassObjectAnnotation get(@NotNull PsiClass psiClass) { PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiClass, JvmStdlibNames.JET_CLASS_OBJECT.getFqName().getFqName()); + JavaAnnotationResolver.findOwnAnnotation(psiClass, JvmStdlibNames.JET_CLASS_OBJECT.getFqName().asString()); return annotation != null ? new JetClassObjectAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java index 65f8277994a..f83f0c17e0d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetConstructorAnnotation.java @@ -48,7 +48,7 @@ public class JetConstructorAnnotation extends PsiAnnotationWithFlags { public static JetConstructorAnnotation get(PsiMethod constructor) { PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(constructor, JvmStdlibNames.JET_CONSTRUCTOR.getFqName().getFqName()); + JavaAnnotationResolver.findOwnAnnotation(constructor, JvmStdlibNames.JET_CONSTRUCTOR.getFqName().asString()); return annotation != null ? new JetConstructorAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java index e1354bd4789..88a3e5066ca 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetMethodAnnotation.java @@ -69,7 +69,7 @@ public class JetMethodAnnotation extends PsiAnnotationWithFlags { public static JetMethodAnnotation get(PsiMethod psiMethod) { PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiMethod, JvmStdlibNames.JET_METHOD.getFqName().getFqName()); + JavaAnnotationResolver.findOwnAnnotation(psiMethod, JvmStdlibNames.JET_METHOD.getFqName().asString()); return annotation != null ? new JetMethodAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java index db7f552fe0d..7ef2fe8d895 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java @@ -36,7 +36,7 @@ public class JetPackageClassAnnotation extends PsiAnnotationWithAbiVersion { @NotNull public static JetPackageClassAnnotation get(PsiClass psiClass) { PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass, - JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().getFqName()); + JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().asString()); return annotation != null ? new JetPackageClassAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java index dfee4f4cd85..8d4a5f17758 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetTypeParameterAnnotation.java @@ -40,7 +40,7 @@ public class JetTypeParameterAnnotation extends PsiAnnotationWrapper { @NotNull public static JetTypeParameterAnnotation get(@NotNull PsiParameter psiParameter) { PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_TYPE_PARAMETER.getFqName().getFqName()); + JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_TYPE_PARAMETER.getFqName().asString()); return annotation != null ? new JetTypeParameterAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java index b03e027d6cf..97b1771d76b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetValueParameterAnnotation.java @@ -77,7 +77,7 @@ public class JetValueParameterAnnotation extends PsiAnnotationWrapper { public static JetValueParameterAnnotation get(PsiParameter psiParameter) { PsiAnnotation annotation = - JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_VALUE_PARAMETER.getFqName().getFqName()); + JavaAnnotationResolver.findOwnAnnotation(psiParameter, JvmStdlibNames.JET_VALUE_PARAMETER.getFqName().asString()); return annotation != null ? new JetValueParameterAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/KotlinSignatureAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/KotlinSignatureAnnotation.java index fccc0b2e414..e27d70f5b31 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/KotlinSignatureAnnotation.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/KotlinSignatureAnnotation.java @@ -50,7 +50,7 @@ public class KotlinSignatureAnnotation extends PsiAnnotationWrapper { @NotNull public static KotlinSignatureAnnotation get(PsiModifierListOwner psiModifierListOwner) { PsiAnnotation annotation = - JavaAnnotationResolver.findAnnotationWithExternal(psiModifierListOwner, JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().getFqName()); + JavaAnnotationResolver.findAnnotationWithExternal(psiModifierListOwner, JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString()); return annotation != null ? new KotlinSignatureAnnotation(annotation) : NULL_ANNOTATION; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index 1b3eaa095d8..7443865b3d0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -413,7 +413,7 @@ public final class MembersCache { return null; } String qualifiedName = psiClass.getQualifiedName(); - if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.getFqName() + ".")) { + if (qualifiedName == null || qualifiedName.startsWith(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.asString() + ".")) { return null; } if (!psiClass.isInterface() || psiClass.isAnnotationType()) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index 2e4e1afed45..07e56506faf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -84,7 +84,7 @@ public final class JavaAnnotationResolver { } // Don't process internal jet annotations and jetbrains NotNull annotations - if (qname.startsWith("jet.runtime.typeinfo.") || qname.equals(JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().getFqName())) { + if (qname.startsWith("jet.runtime.typeinfo.") || qname.equals(JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString())) { return null; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java index 50cac772c7b..8bf16a28584 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassObjectResolver.java @@ -131,7 +131,7 @@ public final class JavaClassObjectResolver { ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); ClassPsiDeclarationProvider data = semanticServices.getPsiDeclarationProviderFactory().createSyntheticClassObjectClassData(psiClass); - setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().getName())); + setUpClassObjectDescriptor(classObjectDescriptor, containing, fqName, data, getClassObjectName(containing.getName().asString())); return classObjectDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 980ad38d540..f280910e44e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -44,7 +44,6 @@ import org.jetbrains.jet.lang.resolve.name.FqNameBase; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeSubstitutor; import org.jetbrains.jet.lang.types.TypeUtils; import javax.inject.Inject; @@ -203,7 +202,7 @@ public final class JavaClassResolver { private static boolean isTraitImplementation(@NotNull FqName qualifiedName) { // TODO: only if -$$TImpl class is created by Kotlin - return qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX); + return qualifiedName.asString().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX); } @NotNull @@ -295,7 +294,7 @@ public final class JavaClassResolver { String containerQualifiedName = methodContainer.getQualifiedName(); assert containerQualifiedName != null : "qualified name is null for " + psiClass; - if (DescriptorUtils.getFQName(samInterface).getFqName().equals(containerQualifiedName)) { + if (DescriptorUtils.getFQName(samInterface).asString().equals(containerQualifiedName)) { SimpleFunctionDescriptor abstractMethod = functionResolver.resolveFunctionMutely(new PsiMethodWrapper(samInterfaceMethod), samInterface); assert abstractMethod != null : "couldn't resolve method " + samInterfaceMethod; @@ -378,7 +377,7 @@ public final class JavaClassResolver { private static FqNameUnsafe javaClassToKotlinFqName(@NotNull FqName rawFqName) { List correctedSegments = new ArrayList(); for (Name segment : rawFqName.pathSegments()) { - if (JvmAbi.CLASS_OBJECT_CLASS_NAME.equals(segment.getName())) { + if (JvmAbi.CLASS_OBJECT_CLASS_NAME.equals(segment.asString())) { assert !correctedSegments.isEmpty(); Name previous = correctedSegments.get(correctedSegments.size() - 1); correctedSegments.add(DescriptorUtils.getClassObjectName(previous)); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 5a6ca428aaf..b85f90e7b20 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -125,7 +125,7 @@ public final class JavaFunctionResolver { // TODO: unless maybe class explicitly extends Object assert containingClass != null; String ownerClassName = containingClass.getQualifiedName(); - if (DescriptorResolverUtils.OBJECT_FQ_NAME.getFqName().equals(ownerClassName)) { + if (DescriptorResolverUtils.OBJECT_FQ_NAME.asString().equals(ownerClassName)) { return null; } } @@ -439,7 +439,7 @@ public final class JavaFunctionResolver { transformedType = typeTransformer.transformToType(returnType, typeUsage, typeVariableResolver); } - if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().getFqName()) != + if (JavaAnnotationResolver.findAnnotationWithExternal(method.getPsiMethod(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != null) { return TypeUtils.makeNullableAsSpecified(transformedType, false); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 0d83a6affbc..43bdd800784 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -392,7 +392,7 @@ public final class JavaPropertyResolver { boolean hasNotNullAnnotation = JavaAnnotationResolver.findAnnotationWithExternal( characteristicMember.getType().getPsiNotNullOwner(), - JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().getFqName()) != null; + JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != null; if (hasNotNullAnnotation || members.isStaticFinalField()) { propertyType = TypeUtils.makeNotNullable(propertyType); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index baa581a7593..eb313a72a3a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -90,7 +90,7 @@ public final class JavaValueParameterResolver { else { JetType transformedType; - if (JavaAnnotationResolver.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().getFqName()) != + if (JavaAnnotationResolver.findAnnotationWithExternal(parameter.getPsiParameter(), JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString()) != null) { transformedType = TypeUtils.makeNullableAsSpecified(outType, false); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorImpl.java index 0f8cef9366f..765970371c3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorImpl.java @@ -73,7 +73,7 @@ public class ClassDescriptorImpl extends DeclarationDescriptorNonRootImpl implem @Nullable ConstructorDescriptor primaryConstructor, boolean isInner ) { - this.typeConstructor = new TypeConstructorImpl(this, getAnnotations(), sealed, getName().getName(), typeParameters, supertypes); + this.typeConstructor = new TypeConstructorImpl(this, getAnnotations(), sealed, getName().asString(), typeParameters, supertypes); this.memberDeclarations = memberDeclarations; this.constructors = constructors; this.primaryConstructor = primaryConstructor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java index efc3908a579..cdbcddd9a8e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java @@ -109,7 +109,7 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase { this, Collections.emptyList(), // TODO : pass annotations from the class? !getModality().isOverridable(), - getName().getName(), + getName().asString(), typeParameters, supertypes); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java index 0785d3f1554..513e5753afd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java @@ -91,7 +91,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp this, annotations, false, - name.getName(), + name.asString(), Collections.emptyList(), upperBounds); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java index 42bc78af206..189fe0e31e7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java @@ -64,7 +64,7 @@ public class Renderers { @Override public String render(@NotNull Object element) { if (element instanceof Named) { - return ((Named) element).getName().getName(); + return ((Named) element).getName().asString(); } return element.toString(); } @@ -299,7 +299,7 @@ public class Renderers { StringBuilder sb = new StringBuilder(); int index = 0; for (ClassDescriptor descriptor : descriptors) { - sb.append(DescriptorUtils.getFQName(descriptor).getFqName()); + sb.append(DescriptorUtils.getFQName(descriptor).asString()); index++; if (index <= descriptors.size() - 2) { sb.append(", "); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java index 67454adfe79..3856f9274da 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java @@ -199,7 +199,7 @@ public class JetClass extends JetTypeParameterListOwnerStub imp PsiJetClassStub stub = getStub(); if (stub != null) { FqName fqName = stub.getFqName(); - return fqName == null ? null : fqName.getFqName(); + return fqName == null ? null : fqName.asString(); } List parts = new ArrayList(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java index cfb5dfd6f59..c9f83314700 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiFactory.java @@ -228,7 +228,7 @@ public class JetPsiFactory { Name alias = importPath.getAlias(); if (alias != null) { - importDirectiveBuilder.append(" as ").append(alias.getName()); + importDirectiveBuilder.append(" as ").append(alias.asString()); } JetFile namespace = createFile(project, importDirectiveBuilder.toString()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index d54ddbe6179..0d02f57ad50 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -408,7 +408,7 @@ public class JetPsiUtil { return false; } - return KotlinBuiltIns.getInstance().getUnit().getName().getName().equals(typeReference.getText()); + return KotlinBuiltIns.getInstance().getUnit().getName().asString().equals(typeReference.getText()); } public static boolean isSafeCall(@NotNull Call call) { @@ -694,7 +694,7 @@ public class JetPsiUtil { public static boolean checkVariableDeclarationInBlock(@NotNull JetBlockExpression block, @NotNull String varName) { for (JetElement element : block.getStatements()) { if (element instanceof JetVariableDeclaration) { - if (((JetVariableDeclaration) element).getNameAsSafeName().getName().equals(varName)) { + if (((JetVariableDeclaration) element).getNameAsSafeName().asString().equals(varName)) { return true; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetAnnotationElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetAnnotationElementType.java index e0e61ca6f1b..a4fb74d67f8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetAnnotationElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetAnnotationElementType.java @@ -50,7 +50,7 @@ public class JetAnnotationElementType extends JetStubElementType redeclaration : redeclarations) { - trace.report(REDECLARATION.on(redeclaration.getFirst(), redeclaration.getSecond().getName())); + trace.report(REDECLARATION.on(redeclaration.getFirst(), redeclaration.getSecond().asString())); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index 8f81456e19e..8e152184462 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -280,7 +280,7 @@ public class DeclarationsChecker { boolean inEnum = classDescriptor.getKind() == ClassKind.ENUM_CLASS; boolean inAbstractClass = classDescriptor.getModality() == Modality.ABSTRACT; if (hasAbstractModifier && !inAbstractClass && !inEnum) { - trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName().getName(), classDescriptor)); + trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName().asString(), classDescriptor)); } if (hasAbstractModifier && inTrait) { trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(function)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 73d15c0171f..5a48b391d44 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -363,7 +363,7 @@ public class DescriptorUtils { @NotNull public static Name getClassObjectName(@NotNull Name className) { - return getClassObjectName(className.getName()); + return getClassObjectName(className.asString()); } @NotNull @@ -405,7 +405,7 @@ public class DescriptorUtils { String typeSuffix = rendererForTypesIfNecessary == null ? "" : ": " + rendererForTypesIfNecessary.renderType(value.getType(KotlinBuiltIns.getInstance())); - resultList.add(entry.getKey().getName().getName() + " = " + value.toString() + typeSuffix); + resultList.add(entry.getKey().getName().asString() + " = " + value.toString() + typeSuffix); } Collections.sort(resultList); return resultList; @@ -536,14 +536,14 @@ public class DescriptorUtils { public static boolean isEnumValueOfMethod(@NotNull FunctionDescriptor functionDescriptor) { List methodTypeParameters = functionDescriptor.getValueParameters(); JetType nullableString = TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getStringType()); - return "valueOf".equals(functionDescriptor.getName().getName()) + return "valueOf".equals(functionDescriptor.getName().asString()) && methodTypeParameters.size() == 1 && JetTypeChecker.INSTANCE.isSubtypeOf(methodTypeParameters.get(0).getType(), nullableString); } public static boolean isEnumValuesMethod(@NotNull FunctionDescriptor functionDescriptor) { List methodTypeParameters = functionDescriptor.getValueParameters(); - return "values".equals(functionDescriptor.getName().getName()) + return "values".equals(functionDescriptor.getName().asString()) && methodTypeParameters.isEmpty(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java index 8a3b2767337..74d44af8791 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java @@ -50,12 +50,12 @@ public final class ImportPath { } public String getPathStr() { - return fqName.getFqName() + (isAllUnder ? ".*" : ""); + return fqName.asString() + (isAllUnder ? ".*" : ""); } @Override public String toString() { - return getPathStr() + (alias != null ? " as " + alias.getName() : ""); + return getPathStr() + (alias != null ? " as " + alias.asString() : ""); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index 77092aee56f..b6fa118fe2d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -75,7 +75,7 @@ public class OverloadResolver { } Key(NamespaceDescriptor namespaceDescriptor, Name name) { - this(DescriptorUtils.getFQName(namespaceDescriptor).getFqName(), name); + this(DescriptorUtils.getFQName(namespaceDescriptor).asString(), name); } public String getNamespace() { @@ -149,7 +149,7 @@ public class OverloadResolver { } if (jetClass instanceof JetObjectDeclaration) { // must be class object - name = classDescriptor.getContainingDeclaration().getName().getName(); + name = classDescriptor.getContainingDeclaration().getName().asString(); return "class object " + name; } // safe @@ -223,7 +223,7 @@ public class OverloadResolver { CallableMemberDescriptor memberDescriptor = redeclaration.getSecond(); JetDeclaration jetDeclaration = redeclaration.getFirst(); if (memberDescriptor instanceof PropertyDescriptor) { - trace.report(Errors.REDECLARATION.on(jetDeclaration, memberDescriptor.getName().getName())); + trace.report(Errors.REDECLARATION.on(jetDeclaration, memberDescriptor.getName().asString())); } else { trace.report(Errors.CONFLICTING_OVERLOADS.on(jetDeclaration, memberDescriptor, functionContainer)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index ce6fce5853b..e1bca7991dd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -155,7 +155,7 @@ public class OverrideResolver { public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) { JetDeclaration declaration = (JetDeclaration) BindingContextUtils .descriptorToDeclaration(trace.getBindingContext(), fromCurrent); - trace.report(Errors.CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().getName())); + trace.report(Errors.CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().asString())); } }); } @@ -586,7 +586,7 @@ public class OverrideResolver { private void checkOverrideForMember(@NotNull final CallableMemberDescriptor declared) { if (declared.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) { // TODO: this should be replaced soon by a framework of synthesized member generation tools - if (declared.getName().getName().startsWith(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX)) { + if (declared.getName().asString().startsWith(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX)) { checkOverrideForComponentFunction(declared); } return; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java index 62b7f5f80c8..4d58f1a80b5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java @@ -39,7 +39,7 @@ public class TraceBasedRedeclarationHandler implements RedeclarationHandler { private void report(DeclarationDescriptor descriptor) { PsiElement firstElement = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), descriptor); if (firstElement != null) { - trace.report(REDECLARATION.on(firstElement, descriptor.getName().getName())); + trace.report(REDECLARATION.on(firstElement, descriptor.getName().asString())); } else { throw new IllegalStateException("No declaration found for " + descriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 61f7a61f92c..8c2e1ae7c59 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -342,7 +342,7 @@ public class TypeResolver { assert size != 0 : "No projections possible for a nilary type constructor" + constructor; ClassifierDescriptor declarationDescriptor = constructor.getDeclarationDescriptor(); assert declarationDescriptor != null : "No declaration descriptor for type constructor " + constructor; - String name = declarationDescriptor.getName().getName(); + String name = declarationDescriptor.getName().asString(); return TypeUtils.getTypeNameAndStarProjectionsString(name, size); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index cfe2429f578..39bf46044f7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -51,7 +51,6 @@ import org.jetbrains.jet.lexer.JetTokens; import javax.inject.Inject; import java.util.Collection; import java.util.Collections; -import java.util.EnumSet; import java.util.List; import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; @@ -100,7 +99,7 @@ public class CallResolver { Name referencedName = nameExpression.getReferencedNameAsName(); List> callableDescriptorCollectors = Lists.newArrayList(); if (nameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) { - referencedName = Name.identifier(referencedName.getName().substring(1)); + referencedName = Name.identifier(referencedName.asString().substring(1)); callableDescriptorCollectors.add(CallableDescriptorCollectors.PROPERTIES); } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TracingStrategyImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TracingStrategyImpl.java index 28a2d4e5ada..07b192aa225 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TracingStrategyImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TracingStrategyImpl.java @@ -178,7 +178,7 @@ public class TracingStrategyImpl implements TracingStrategy { JetExpression left = binaryExpression.getLeft(); JetExpression right = binaryExpression.getRight(); if (left != null && right != null) { - trace.report(UNSAFE_INFIX_CALL.on(reference, left.getText(), operationString.getName(), right.getText())); + trace.report(UNSAFE_INFIX_CALL.on(reference, left.getText(), operationString.asString(), right.getText())); } } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java index a8b6be66903..90843cb75ad 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java @@ -124,7 +124,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope { } @NotNull - public String getName() { + public String asString() { return name; } @@ -38,7 +38,7 @@ public final class Name implements Comparable { if (special) { throw new IllegalStateException("not identifier: " + this); } - return getName(); + return asString(); } public boolean isSpecial() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 04a2e6e6772..7f1c06745b2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -176,7 +176,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { checkMayWrite(); Map> labelsToDescriptors = getLabelsToDescriptors(); - LabelName name = new LabelName(descriptor.getName().getName()); + LabelName name = new LabelName(descriptor.getName().asString()); List declarationDescriptors = labelsToDescriptors.get(name); if (declarationDescriptors == null) { declarationDescriptors = new ArrayList(); @@ -481,7 +481,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { public PropertyDescriptor getPropertyByFieldReference(@NotNull Name fieldName) { checkMayRead(); - if (!fieldName.getName().startsWith("$")) { + if (!fieldName.asString().startsWith("$")) { throw new IllegalStateException(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index a6bee531df6..98c8207ad23 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -792,13 +792,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { assert returnType != null : "returnType is null for " + resolutionResults.getResultingDescriptor(); if (JetTypeChecker.INSTANCE.isSubtypeOf(returnType, KotlinBuiltIns.getInstance().getUnitType())) { - result = ErrorUtils.createErrorType(KotlinBuiltIns.getInstance().getUnit().getName().getName()); + result = ErrorUtils.createErrorType(KotlinBuiltIns.getInstance().getUnit().getName().asString()); context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign)); } else { JetType receiverType = receiver.getType(); if (!JetTypeChecker.INSTANCE.isSubtypeOf(returnType, receiverType)) { - context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name.getName(), receiverType, returnType)); + context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name.asString(), receiverType, returnType)); } else { context.trace.record(BindingContext.VARIABLE_REASSIGNMENT, expression); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index f3c71c4b93d..18f6e7f361e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -339,7 +339,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { VariableDescriptor olderVariable = context.scope.getLocalVariable(variableDescriptor.getName()); if (olderVariable != null && DescriptorUtils.isLocal(context.scope.getContainingDeclaration(), olderVariable)) { PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), variableDescriptor); - context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().getName())); + context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().asString())); } } return variableDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DelegatedPropertyUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DelegatedPropertyUtils.java index a80402c2e53..c852ed51ad2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DelegatedPropertyUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DelegatedPropertyUtils.java @@ -136,7 +136,7 @@ public class DelegatedPropertyUtils { List arguments = Lists.newArrayList(); arguments.add(createExpression(project, hasThis ? "this" : "null")); - arguments.add(createExpression(project, KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().getName() + "(\"" + propertyDescriptor.getName().getName() + "\")")); + arguments.add(createExpression(project, KotlinBuiltIns.getInstance().getPropertyMetadataImpl().getName().asString() + "(\"" + propertyDescriptor.getName().asString() + "\")")); if (!isGet) { JetReferenceExpression fakeArgument = (JetReferenceExpression) createFakeExpressionOfType(context.expressionTypingServices.getProject(), trace, @@ -148,7 +148,7 @@ public class DelegatedPropertyUtils { } Name functionName = Name.identifier(isGet ? "get" : "set"); - JetReferenceExpression fakeCalleeExpression = createSimpleName(project, functionName.getName()); + JetReferenceExpression fakeCalleeExpression = createSimpleName(project, functionName.asString()); ExpressionReceiver receiver = new ExpressionReceiver(delegateExpression, delegateType); call = CallMaker.makeCallWithExpressions(fakeCalleeExpression, receiver, null, fakeCalleeExpression, arguments, Call.CallType.DEFAULT); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 1e1d6e9f60d..6cd8259c5fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -237,7 +237,7 @@ public class ExpressionTypingUtils { @NotNull JetScope scope, @NotNull ModuleDescriptor module ) { - JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, callableFQN.getFqName()); + JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, callableFQN.asString()); Collection declarationDescriptors = new QualifiedExpressionResolver() .analyseImportReference(importDirective, scope, new BindingTraceContext(), module); @@ -436,7 +436,7 @@ public class ExpressionTypingUtils { if (oldDescriptor != null && DescriptorUtils.isLocal(variableDescriptor.getContainingDeclaration(), oldDescriptor)) { PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context.trace.getBindingContext(), variableDescriptor); if (declaration != null) { - context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().getName())); + context.trace.report(Errors.NAME_SHADOWING.on(declaration, variableDescriptor.getName().asString())); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 3057b763e8f..fa9cd738836 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -263,9 +263,9 @@ public class KotlinBuiltIns { } private void makePrimitive(PrimitiveType primitiveType) { - ClassDescriptor theClass = getBuiltInClassByName(primitiveType.getTypeName().getName()); + ClassDescriptor theClass = getBuiltInClassByName(primitiveType.getTypeName().asString()); JetType type = new JetTypeImpl(theClass); - ClassDescriptor arrayClass = getBuiltInClassByName(primitiveType.getArrayTypeName().getName()); + ClassDescriptor arrayClass = getBuiltInClassByName(primitiveType.getArrayTypeName().asString()); JetType arrayType = new JetTypeImpl(arrayClass); primitiveTypeToClass.put(primitiveType, theClass); @@ -335,7 +335,7 @@ public class KotlinBuiltIns { @NotNull public ClassDescriptor getPrimitiveClassDescriptor(@NotNull PrimitiveType type) { - return getBuiltInClassByName(type.getTypeName().getName()); + return getBuiltInClassByName(type.getTypeName().asString()); } @NotNull @@ -398,7 +398,7 @@ public class KotlinBuiltIns { @NotNull public ClassDescriptor getPrimitiveArrayClassDescriptor(@NotNull PrimitiveType type) { - return getBuiltInClassByName(type.getArrayTypeName().getName()); + return getBuiltInClassByName(type.getArrayTypeName().asString()); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java index 85384187dc5..9f78eb1dde8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/QualifiedNamesUtil.java @@ -39,8 +39,8 @@ public final class QualifiedNamesUtil { return true; } - String subpackageNameStr = subpackageName.getFqName(); - String packageNameStr = packageName.getFqName(); + String subpackageNameStr = subpackageName.asString(); + String packageNameStr = packageName.asString(); return (subpackageNameStr.startsWith(packageNameStr) && subpackageNameStr.charAt(packageNameStr.length()) == '.'); } @@ -54,7 +54,7 @@ public final class QualifiedNamesUtil { } public static boolean isOneSegmentFQN(@NotNull FqName fqn) { - return isOneSegmentFQN(fqn.getFqName()); + return isOneSegmentFQN(fqn.asString()); } @NotNull @@ -74,7 +74,7 @@ public final class QualifiedNamesUtil { return FqName.ROOT; } - String fqNameStr = fqName.getFqName(); + String fqNameStr = fqName.asString(); return new FqName(fqNameStr.substring(fqNameStr.indexOf('.'), fqNameStr.length())); } @@ -93,12 +93,12 @@ public final class QualifiedNamesUtil { @NotNull public static String tail(@NotNull FqName headFQN, @NotNull FqName fullFQN) { if (!isSubpackageOf(fullFQN, headFQN) || headFQN.isRoot()) { - return fullFQN.getFqName(); + return fullFQN.asString(); } return fullFQN.equals(headFQN) ? "" : - fullFQN.getFqName().substring(headFQN.getFqName().length() + 1); // (headFQN + '.').length + fullFQN.asString().substring(headFQN.asString().length() + 1); // (headFQN + '.').length } /** diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightPackage.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightPackage.java index 84548b8a917..aae66c8a4d9 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightPackage.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightPackage.java @@ -31,7 +31,7 @@ public class JetLightPackage extends PsiPackageImpl { private final GlobalSearchScope scope; public JetLightPackage(PsiManager manager, FqName qualifiedName, GlobalSearchScope scope) { - super(manager, qualifiedName.getFqName()); + super(manager, qualifiedName.asString()); this.fqName = qualifiedName; this.scope = scope; } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java index d6f04fcad3f..2a4a9da49ee 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinJavaFileStubProvider.java @@ -189,7 +189,7 @@ public class KotlinJavaFileStubProvider implements CachedValueProvider stub) { - if (stub instanceof PsiClassStub && Comparing.equal(fqn.getFqName(), ((PsiClassStub) stub).getQualifiedName())) { + if (stub instanceof PsiClassStub && Comparing.equal(fqn.asString(), ((PsiClassStub) stub).getQualifiedName())) { return (PsiClass)stub.getPsi(); } @@ -222,7 +222,7 @@ public class LightClassUtil { if (jvmName != null) { Project project = declaration.getProject(); - String fqName = jvmName.getFqName().getFqName(); + String fqName = jvmName.getFqName().asString(); return JavaElementFinder.getInstance(project).findClass(fqName, GlobalSearchScope.allScope(project)); } } diff --git a/compiler/tests/org/jetbrains/jet/FqNameTest.java b/compiler/tests/org/jetbrains/jet/FqNameTest.java index 9397ca49cee..bcd2b1d8414 100644 --- a/compiler/tests/org/jetbrains/jet/FqNameTest.java +++ b/compiler/tests/org/jetbrains/jet/FqNameTest.java @@ -34,46 +34,46 @@ public class FqNameTest { public void pathRoot() { List path = new FqName("").path(); Assert.assertEquals(1, path.size()); - Assert.assertEquals("", path.get(0).getFqName()); + Assert.assertEquals("", path.get(0).asString()); } @Test public void pathLevel1() { List path = new FqName("com").path(); Assert.assertEquals(2, path.size()); - Assert.assertEquals("", path.get(0).getFqName()); - Assert.assertEquals("com", path.get(1).getFqName()); - Assert.assertEquals("com", path.get(1).shortName().getName()); - Assert.assertEquals("", path.get(1).parent().getFqName()); + Assert.assertEquals("", path.get(0).asString()); + Assert.assertEquals("com", path.get(1).asString()); + Assert.assertEquals("com", path.get(1).shortName().asString()); + Assert.assertEquals("", path.get(1).parent().asString()); } @Test public void pathLevel2() { List path = new FqName("com.jetbrains").path(); Assert.assertEquals(3, path.size()); - Assert.assertEquals("", path.get(0).getFqName()); - Assert.assertEquals("com", path.get(1).getFqName()); - Assert.assertEquals("com", path.get(1).shortName().getName()); - Assert.assertEquals("", path.get(1).parent().getFqName()); - Assert.assertEquals("com.jetbrains", path.get(2).getFqName()); - Assert.assertEquals("jetbrains", path.get(2).shortName().getName()); - Assert.assertEquals("com", path.get(2).parent().getFqName()); + Assert.assertEquals("", path.get(0).asString()); + Assert.assertEquals("com", path.get(1).asString()); + Assert.assertEquals("com", path.get(1).shortName().asString()); + Assert.assertEquals("", path.get(1).parent().asString()); + Assert.assertEquals("com.jetbrains", path.get(2).asString()); + Assert.assertEquals("jetbrains", path.get(2).shortName().asString()); + Assert.assertEquals("com", path.get(2).parent().asString()); } @Test public void pathLevel3() { List path = new FqName("com.jetbrains.jet").path(); Assert.assertEquals(4, path.size()); - Assert.assertEquals("", path.get(0).getFqName()); - Assert.assertEquals("com", path.get(1).getFqName()); - Assert.assertEquals("com", path.get(1).shortName().getName()); - Assert.assertEquals("", path.get(1).parent().getFqName()); - Assert.assertEquals("com.jetbrains", path.get(2).getFqName()); - Assert.assertEquals("jetbrains", path.get(2).shortName().getName()); - Assert.assertEquals("com", path.get(2).parent().getFqName()); - Assert.assertEquals("com.jetbrains.jet", path.get(3).getFqName()); - Assert.assertEquals("jet", path.get(3).shortName().getName()); - Assert.assertEquals("com.jetbrains", path.get(3).parent().getFqName()); + Assert.assertEquals("", path.get(0).asString()); + Assert.assertEquals("com", path.get(1).asString()); + Assert.assertEquals("com", path.get(1).shortName().asString()); + Assert.assertEquals("", path.get(1).parent().asString()); + Assert.assertEquals("com.jetbrains", path.get(2).asString()); + Assert.assertEquals("jetbrains", path.get(2).shortName().asString()); + Assert.assertEquals("com", path.get(2).parent().asString()); + Assert.assertEquals("com.jetbrains.jet", path.get(3).asString()); + Assert.assertEquals("jet", path.get(3).shortName().asString()); + Assert.assertEquals("com.jetbrains", path.get(3).parent().asString()); } @Test @@ -84,7 +84,7 @@ public class FqNameTest { List segments = new FqName(name).pathSegments(); List segmentsStrings = new ArrayList(); for (Name segment : segments) { - segmentsStrings.add(segment.getName()); + segmentsStrings.add(segment.asString()); } Assert.assertEquals(Arrays.asList(name.split("\\.")), segmentsStrings); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index b456eb546ad..ec039288105 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -137,7 +137,7 @@ public abstract class CodegenTestCase extends UsefulTestCase { @NotNull protected Class generateNamespaceClass() { JvmClassName name = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(myFiles.getPsiFile())); - return generateClass(name.getFqName().getFqName()); + return generateClass(name.getFqName().asString()); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java b/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java index 4f0b48715e8..b5a729460be 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/AbstractBlackBoxCodegenTest.java @@ -97,7 +97,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase { // If there are many files, the first of them should contain the 'box(): String' function JetFile firstFile = myFiles.getPsiFiles().get(0); - String fqName = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(firstFile)).getFqName().getFqName(); + String fqName = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(firstFile)).getFqName().asString(); try { Class namespaceClass = loader.loadClass(fqName); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java index ce0f25443a5..c9c3adaf9e8 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java @@ -54,7 +54,7 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); assert namespaceFromSource != null; - Assert.assertEquals("test", namespaceFromSource.getName().getName()); + Assert.assertEquals("test", namespaceFromSource.getName().asString()); NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first; compareNamespaces(namespaceFromSource, namespaceFromClass, diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java index 85f5bf952f8..07c2b97aa3b 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java @@ -28,7 +28,6 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.renderer.DescriptorRenderer; -import java.io.File; import java.util.*; import static com.intellij.testFramework.UsefulTestCase.assertNotNull; @@ -85,7 +84,7 @@ public class ExpectedLoadErrorsUtil { ClassDescriptor annotationClass = (ClassDescriptor) annotation.getType().getConstructor().getDeclarationDescriptor(); assert annotationClass != null; - if (DescriptorUtils.getFQName(annotationClass).getFqName().equals(ANNOTATION_CLASS_NAME)) { + if (DescriptorUtils.getFQName(annotationClass).asString().equals(ANNOTATION_CLASS_NAME)) { // we expect exactly one annotation argument CompileTimeConstant argument = annotation.getAllValueArguments().values().iterator().next(); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java index e2819d69c09..e1df228e34e 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java @@ -79,7 +79,7 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { if (new FqName("org.jdom").equals(classFqName.parent())) continue; // filter unrelated jdom annotations if (new FqName("java.util.concurrent.TransferQueue").equals(classFqName)) continue; // filter JDK7-specific class - PsiClass psiClass = javaPsiFacade.findClass(classFqName.getFqName(), allScope); + PsiClass psiClass = javaPsiFacade.findClass(classFqName.asString(), allScope); assertNotNull("Class has annotation, but it is not found: " + classFqName, psiClass); psiClass.accept(new JavaRecursiveElementVisitor() { @@ -111,7 +111,7 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { if (hasAnnotation(ideaFakeAnnotationsManager, ideaOwner, AnnotationUtil.NOT_NULL)) { boolean kotlinHasNotNull = hasAnnotation(kotlinFakeAnnotationsManager, kotlinOwner, AnnotationUtil.NOT_NULL); boolean kotlinHasKotlinSignature = hasAnnotation(kotlinFakeAnnotationsManager, kotlinOwner, - JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().getFqName()); + JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString()); if (kotlinOwner == ideaOwner && kotlinHasNotNull || kotlinHasKotlinSignature) { // good } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/JvmClassNameTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/JvmClassNameTest.java index 464387b34a1..073d95b9e91 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/JvmClassNameTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/JvmClassNameTest.java @@ -61,8 +61,8 @@ public class JvmClassNameTest { ) { JvmClassName mapEntryName = JvmClassName.bySignatureName(className); assertEquals(innerClassName, mapEntryName.getInternalName()); - assertEquals(fqName, mapEntryName.getFqName().getFqName()); - assertEquals(outerClassName, mapEntryName.getOuterClassFqName().getFqName()); + assertEquals(fqName, mapEntryName.getFqName().asString()); + assertEquals(outerClassName, mapEntryName.getOuterClassFqName().asString()); assertEquals(innerClassNameList, mapEntryName.getInnerClassNameList()); } } diff --git a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java index e89935e7fd4..ad16bcc839f 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java @@ -131,7 +131,7 @@ public class NamespaceComparator { private boolean shouldSkip(@NotNull DeclarationDescriptor subDescriptor) { return subDescriptor.getContainingDeclaration() instanceof ClassDescriptor && subDescriptor instanceof FunctionDescriptor - && JAVA_OBJECT_METHOD_NAMES.contains(subDescriptor.getName().getName()) + && JAVA_OBJECT_METHOD_NAMES.contains(subDescriptor.getName().asString()) && !conf.includeMethodsOfJavaObject || subDescriptor instanceof NamespaceDescriptor && !conf.recurseIntoPackage.apply(DescriptorUtils.getFQName(subDescriptor)); diff --git a/generators/org/jetbrains/jet/generators/jvm/GenerateJavaToKotlinMethodMap.java b/generators/org/jetbrains/jet/generators/jvm/GenerateJavaToKotlinMethodMap.java index 933ef159530..429c88b11c0 100644 --- a/generators/org/jetbrains/jet/generators/jvm/GenerateJavaToKotlinMethodMap.java +++ b/generators/org/jetbrains/jet/generators/jvm/GenerateJavaToKotlinMethodMap.java @@ -53,7 +53,7 @@ import static org.jetbrains.jet.lang.resolve.java.JavaToKotlinMethodMap.serializ public class GenerateJavaToKotlinMethodMap { - public static final String BUILTINS_FQNAME_PREFIX = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.getFqName() + "."; + public static final String BUILTINS_FQNAME_PREFIX = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.asString() + "."; public static void main(String[] args) throws IOException { CompilerConfiguration configuration = new CompilerConfiguration(); @@ -207,7 +207,7 @@ public class GenerateJavaToKotlinMethodMap { private void appendBeforeClass(@NotNull ClassDescriptor kotlinClass, @NotNull PsiClass psiClass) { String psiFqName = psiClass.getQualifiedName(); - String kotlinFqName = DescriptorUtils.getFQName(kotlinClass).toSafe().getFqName(); + String kotlinFqName = DescriptorUtils.getFQName(kotlinClass).toSafe().asString(); assert kotlinFqName.startsWith(BUILTINS_FQNAME_PREFIX); String kotlinSubQualifiedName = kotlinFqName.substring(BUILTINS_FQNAME_PREFIX.length()); diff --git a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java index f04c8801db8..9d19e277e00 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java @@ -44,11 +44,11 @@ public class JetPluginUtil { LinkedList fullName = Lists.newLinkedList(); while (declarationDescriptor != null && !(declarationDescriptor instanceof ModuleDescriptor)) { - fullName.addFirst(declarationDescriptor.getName().getName()); + fullName.addFirst(declarationDescriptor.getName().asString()); declarationDescriptor = declarationDescriptor.getContainingDeclaration(); } assert fullName.size() > 0; - if (JavaDescriptorResolver.JAVA_ROOT.getName().equals(fullName.getFirst())) { + if (JavaDescriptorResolver.JAVA_ROOT.asString().equals(fullName.getFirst())) { fullName.removeFirst(); } return fullName; diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java index 80430ad6ce4..57bbd85402b 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java @@ -107,7 +107,7 @@ public class JetAddImportAction implements QuestionAction { return FINAL_CHOICE; } - List toExclude = AddImportAction.getAllExcludableStrings(selectedValue.getFqName()); + List toExclude = AddImportAction.getAllExcludableStrings(selectedValue.asString()); return new BaseListPopupStep(null, toExclude) { @NotNull @@ -135,7 +135,7 @@ public class JetAddImportAction implements QuestionAction { @NotNull @Override public String getTextFor(FqName value) { - return value.getFqName(); + return value.asString(); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetGotoClassContributor.java b/idea/src/org/jetbrains/jet/plugin/caches/JetGotoClassContributor.java index 58d6c0e95b8..ac98c103b4a 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetGotoClassContributor.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetGotoClassContributor.java @@ -39,7 +39,7 @@ public class JetGotoClassContributor implements GotoClassContributor { JetNamedDeclaration jetClass = (JetNamedDeclaration) item; FqName name = JetPsiUtil.getFQName(jetClass); if (name != null) { - return name.getFqName(); + return name.asString(); } } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index 2993f177059..38abadfafcf 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -107,7 +107,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { Collection fqNames = packageClasses.get(name); if (!fqNames.isEmpty()) { for (FqName fqName : fqNames) { - PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope); + PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope); if (psiClass != null) { result.add(psiClass); } @@ -123,10 +123,10 @@ public class JetShortNamesCache extends PsiShortNamesCache { for (JetClassOrObject classOrObject : classOrObjects) { FqName fqName = JetPsiUtil.getFQName(classOrObject); if (fqName != null) { - assert fqName.shortName().getName().equals(name) : "A declaration obtained from index has non-matching name:\n" + + assert fqName.shortName().asString().equals(name) : "A declaration obtained from index has non-matching name:\n" + "in index: " + name + "\n" + "declared: " + fqName.shortName() + "(" + fqName + ")"; - PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.getFqName(), scope); + PsiClass psiClass = JavaElementFinder.getInstance(project).findClass(fqName.asString(), scope); if (psiClass != null) { result.add(psiClass); } @@ -230,7 +230,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { Set result = Sets.newHashSet(); Collection topLevelFunctionPrototypes = JetFromJavaDescriptorHelper.getTopLevelFunctionPrototypesByName( - referenceName.getName(), project, scope); + referenceName.asString(), project, scope); for (PsiMethod method : topLevelFunctionPrototypes) { FqName functionFQN = JetFromJavaDescriptorHelper.getJetTopLevelDeclarationFQN(method); if (functionFQN != null) { @@ -246,7 +246,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { } Set affectedPackages = Sets.newHashSet(); - Collection jetNamedFunctions = JetShortFunctionNameIndex.getInstance().get(referenceName.getName(), project, scope); + Collection jetNamedFunctions = JetShortFunctionNameIndex.getInstance().get(referenceName.asString(), project, scope); for (JetNamedFunction jetNamedFunction : jetNamedFunctions) { PsiFile containingFile = jetNamedFunction.getContainingFile(); if (containingFile instanceof JetFile) { @@ -354,7 +354,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { for (String fqName : JetFullClassNameIndex.getInstance().getAllKeys(project)) { FqName classFQName = new FqName(fqName); - if (acceptedShortNameCondition.value(classFQName.shortName().getName())) { + if (acceptedShortNameCondition.value(classFQName.shortName().asString())) { classDescriptors.addAll(getJetClassesDescriptorsByFQName(analyzer, classFQName)); } } @@ -364,7 +364,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { private Collection getJetClassesDescriptorsByFQName(@NotNull KotlinCodeAnalyzer analyzer, @NotNull FqName classFQName) { Collection jetClassOrObjects = JetFullClassNameIndex.getInstance().get( - classFQName.getFqName(), project, GlobalSearchScope.allScope(project)); + classFQName.asString(), project, GlobalSearchScope.allScope(project)); if (jetClassOrObjects.isEmpty()) { // This fqn is absent in caches, dead or not in scope diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java index a35c2cf6997..75365972681 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/IDELightClassGenerationSupport.java @@ -31,11 +31,9 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration; import org.jetbrains.jet.asJava.LightClassConstructionContext; import org.jetbrains.jet.asJava.LightClassGenerationSupport; -import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; -import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper; @@ -70,13 +68,13 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport @NotNull @Override public Collection findClassOrObjectDeclarations(@NotNull FqName fqName, @NotNull GlobalSearchScope searchScope) { - return JetFullClassNameIndex.getInstance().get(fqName.getFqName(), project, kotlinSources(searchScope)); + return JetFullClassNameIndex.getInstance().get(fqName.asString(), project, kotlinSources(searchScope)); } @NotNull @Override public Collection findFilesForPackage(@NotNull final FqName fqName, @NotNull GlobalSearchScope searchScope) { - Collection files = JetAllPackagesIndex.getInstance().get(fqName.getFqName(), project, kotlinSources(searchScope)); + Collection files = JetAllPackagesIndex.getInstance().get(fqName.asString(), project, kotlinSources(searchScope)); return ContainerUtil.filter(files, new Condition() { @Override public boolean value(JetFile file) { @@ -90,20 +88,20 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport public Collection findClassOrObjectDeclarationsInPackage( @NotNull FqName packageFqName, @NotNull GlobalSearchScope searchScope ) { - return JetClassByPackageIndex.getInstance().get(packageFqName.getFqName(), project, kotlinSources(searchScope)); + return JetClassByPackageIndex.getInstance().get(packageFqName.asString(), project, kotlinSources(searchScope)); } @Override public boolean packageExists( @NotNull FqName fqName, @NotNull GlobalSearchScope scope ) { - return !JetAllPackagesIndex.getInstance().get(fqName.getFqName(), project, kotlinSources(scope)).isEmpty(); + return !JetAllPackagesIndex.getInstance().get(fqName.asString(), project, kotlinSources(scope)).isEmpty(); } @NotNull @Override public Collection getSubPackages(@NotNull FqName fqn, @NotNull GlobalSearchScope scope) { - Collection files = JetAllPackagesIndex.getInstance().get(fqn.getFqName(), project, kotlinSources(scope)); + Collection files = JetAllPackagesIndex.getInstance().get(fqn.asString(), project, kotlinSources(scope)); Set result = Sets.newHashSet(); for (JetFile file : files) { @@ -141,7 +139,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport Collection files = findFilesForPackage(new FqName(packageFqName), scope); if (!files.isEmpty()) { FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(new FqName(packageFqName)); - result.putValue(packageClassFqName.shortName().getName(), packageClassFqName); + result.putValue(packageClassFqName.shortName().asString(), packageClassFqName); } } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java index 6831179e9e2..d312e623cb3 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java @@ -81,7 +81,7 @@ public class ReferenceToClassesShortening { } private void compactReferenceToClass(JetUserType userType, ClassDescriptor targetClass) { - String name = targetClass.getName().getName(); + String name = targetClass.getName().asString(); DeclarationDescriptor parent = targetClass.getContainingDeclaration(); while (parent instanceof ClassDescriptor) { name = parent.getName() + "." + name; diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureUtil.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureUtil.java index 773d9e2f247..65af5942ce2 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureUtil.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; class KotlinSignatureUtil { - static final String KOTLIN_SIGNATURE_ANNOTATION = JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().getFqName(); + static final String KOTLIN_SIGNATURE_ANNOTATION = JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString(); private KotlinSignatureUtil() { } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java index 38f33ad85fb..c1116b5c19b 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java @@ -68,9 +68,9 @@ public final class DescriptorLookupConverter { } LookupElementBuilder element = LookupElementBuilder.create( - new JetLookupObject(descriptor, analyzer, declaration), descriptor.getName().getName()); + new JetLookupObject(descriptor, analyzer, declaration), descriptor.getName().asString()); - String presentableText = descriptor.getName().getName(); + String presentableText = descriptor.getName().asString(); String typeText = ""; String tailText = ""; boolean tailTextGrayed = true; diff --git a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java index d528c38288d..814ded11302 100644 --- a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java @@ -227,7 +227,7 @@ public class JetImportOptimizer implements ImportOptimizer { for (JetSimpleNameExpression nameExpression : simpleNameExpressions) { Name referencedName = nameExpression.getReferencedNameAsName(); if (fqName == null) { - fqName = new FqName(referencedName.getName()); + fqName = new FqName(referencedName.asString()); } else { fqName = QualifiedNamesUtil.combine(fqName, referencedName); } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java b/idea/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java index eac200f4299..cc209359ffd 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java @@ -247,7 +247,7 @@ public class DeprecatedAnnotationVisitor extends AfterAnalysisHighlightingVisito private static String getDescriptorString(@NotNull DeclarationDescriptor descriptor) { if (descriptor instanceof ClassDescriptor) { - return DescriptorUtils.getFQName(descriptor).getFqName(); + return DescriptorUtils.getFQName(descriptor).asString(); } else if (descriptor instanceof ConstructorDescriptor) { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/IdeRenderers.java b/idea/src/org/jetbrains/jet/plugin/highlighter/IdeRenderers.java index 6f45895de6a..ebdaed8df0c 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/IdeRenderers.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/IdeRenderers.java @@ -166,7 +166,7 @@ public class IdeRenderers { DeclarationDescriptor containingDeclaration = funDescriptor.getContainingDeclaration(); if (containingDeclaration != null) { FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration); - stringBuilder.append(FqName.ROOT.equalsTo(fqName) ? "root package" : fqName.getFqName()); + stringBuilder.append(FqName.ROOT.equalsTo(fqName) ? "root package" : fqName.asString()); } stringBuilder.append(""); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java index 36593693a47..e81aa42ffc6 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java @@ -255,7 +255,7 @@ public class JetSourceNavigationHelper { return null; } Collection classes = JetFullClassNameIndex.getInstance() - .get(classFqName.getFqName(), decompiledClassOrObject.getProject(), librarySourcesScope); + .get(classFqName.asString(), decompiledClassOrObject.getProject(), librarySourcesScope); if (classes.isEmpty()) { return null; } @@ -274,7 +274,7 @@ public class JetSourceNavigationHelper { //noinspection unchecked StringStubIndexExtension index = (StringStubIndexExtension) getIndexForTopLevelPropertyOrFunction(decompiledDeclaration); - return index.get(memberFqName.getFqName(), decompiledDeclaration.getProject(), librarySourcesScope); + return index.get(memberFqName.asString(), decompiledDeclaration.getProject(), librarySourcesScope); } private static StringStubIndexExtension getIndexForTopLevelPropertyOrFunction( @@ -360,7 +360,7 @@ public class JetSourceNavigationHelper { if (javaAnalog.getSort() != Type.OBJECT) { return null; } - String fqName = JvmClassName.byType(javaAnalog).getFqName().getFqName(); + String fqName = JvmClassName.byType(javaAnalog).getFqName().asString(); return JavaPsiFacade.getInstance(classOrObject.getProject()). findClass(fqName, GlobalSearchScope.allScope(classOrObject.getProject())); } @@ -378,7 +378,7 @@ public class JetSourceNavigationHelper { if (className == null) { return null; } - String fqName = className.getFqName().getFqName(); + String fqName = className.getFqName().asString(); JetFile file = (JetFile) classOrObject.getContainingFile(); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java b/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java index e4ccd6a6072..d04da005cba 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/MemberMatching.java @@ -84,10 +84,10 @@ public class MemberMatching { int parameterCount = type.getParameters().size(); if (type.getReceiverTypeRef() == null) { - return builtIns.getFunction(parameterCount).getName().getName(); + return builtIns.getFunction(parameterCount).getName().asString(); } else { - return builtIns.getExtensionFunction(parameterCount).getName().getName(); + return builtIns.getExtensionFunction(parameterCount).getName().asString(); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java index bb05a682110..2e2e8b4c1f8 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java @@ -65,7 +65,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix { String subjectSuffix = newParametersCnt > 1 ? "s" : ""; if (functionDescriptor instanceof ConstructorDescriptor) { - String className = functionDescriptor.getContainingDeclaration().getName().getName(); + String className = functionDescriptor.getContainingDeclaration().getName().asString(); if (hasTypeMismatches) return JetBundle.message("change.constructor.signature", className); @@ -73,7 +73,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix { return JetBundle.message("add.parameters.to.constructor", subjectSuffix, className); } else { - String functionName = functionDescriptor.getName().getName(); + String functionName = functionDescriptor.getName().asString(); if (hasTypeMismatches) return JetBundle.message("change.function.signature", functionName); @@ -95,7 +95,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix { JetExpression expression = argument.getArgumentExpression(); if (i < parameters.size()) { - validator.validateName(parameters.get(i).getName().getName()); + validator.validateName(parameters.get(i).getName().asString()); JetType argumentType = expression != null ? bindingContext.get(BindingContext.EXPRESSION_TYPE, expression) : null; JetType parameterType = parameters.get(i).getType(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java index cc0f03947f3..cc53c6ad0e3 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java @@ -75,7 +75,7 @@ public class AddNameToArgumentFix extends JetIntentionAction { Set usedParameters = getUsedParameters(callElement, callableDescriptor); List names = Lists.newArrayList(); for (ValueParameterDescriptor parameter: callableDescriptor.getValueParameters()) { - String name = parameter.getName().getName(); + String name = parameter.getName().asString(); if (usedParameters.contains(name)) continue; if (type == null || JetTypeChecker.INSTANCE.isSubtypeOf(type, parameter.getType())) { names.add(name); @@ -98,7 +98,7 @@ public class AddNameToArgumentFix extends JetIntentionAction { } else if (isPositionalArgument) { ValueParameterDescriptor parameter = callableDescriptor.getValueParameters().get(idx); - usedParameters.add(parameter.getName().getName()); + usedParameters.add(parameter.getName().asString()); idx++; } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java index 5b47b60d8d6..c4cdd8d9533 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java @@ -239,7 +239,7 @@ public class AutoImportFix extends JetHintAction implem } if (!ApplicationManager.getApplication().isUnitTestMode()) { - String hintText = ShowAutoImportPass.getMessage(suggestions.size() > 1, suggestions.iterator().next().getFqName()); + String hintText = ShowAutoImportPass.getMessage(suggestions.size() > 1, suggestions.iterator().next().asString()); HintManager.getInstance().showQuestionHint( editor, hintText, diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java index f27f58cecf8..e8368c9a771 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java @@ -28,7 +28,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters3; import org.jetbrains.jet.lang.psi.*; @@ -58,7 +57,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction) diagnostic).getA().getName(); + String componentName = ((DiagnosticWithParameters3) diagnostic).getA().asString(); int componentIndex = Integer.valueOf(componentName.substring(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX.length())); JetMultiDeclaration multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, JetMultiDeclaration.class); assert multiDeclaration != null : "COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH reported on expression that is not within any multi declaration"; diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java index 7f0e9c84c4a..1763374647c 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -87,7 +87,7 @@ public class ImportInsertHelper { boolean same = file.getManager().areElementsEquivalent(target, targetElement); if (!same) { - same = target instanceof PsiClass && importFqn.getFqName().equals(((PsiClass)target).getQualifiedName()); + same = target instanceof PsiClass && importFqn.asString().equals(((PsiClass)target).getQualifiedName()); } if (!same) { @@ -106,7 +106,7 @@ public class ImportInsertHelper { if (!same) { Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file); TextRange refRange = reference.getElement().getTextRange(); - document.replaceString(refRange.getStartOffset(), refRange.getEndOffset(), importFqn.getFqName()); + document.replaceString(refRange.getStartOffset(), refRange.getEndOffset(), importFqn.asString()); } return; } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MakeOverriddenMemberOpenFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MakeOverriddenMemberOpenFix.java index c3c286131dc..6dbe519d36a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MakeOverriddenMemberOpenFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MakeOverriddenMemberOpenFix.java @@ -69,7 +69,7 @@ public class MakeOverriddenMemberOpenFix extends JetIntentionAction 1) { LinkedHashSet possibleTypes = new LinkedHashSet(); for (ClassDescriptor klass : possibleClasses) { - possibleTypes.add(klass.getName().getName()); + possibleTypes.add(klass.getName().asString()); } buildAndShowTemplate(project, editor, file, replacedElements, possibleTypes); } @@ -120,7 +120,7 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction replaceUsagesWithFirstClass(Project project, List usages) { ClassDescriptor replacementClass = possibleClasses.iterator().next(); - String replacementClassName = replacementClass.getName().getName(); + String replacementClassName = replacementClass.getName().asString(); List replacedElements = new ArrayList(); for (JetUserType usage : usages) { JetTypeArgumentList typeArguments = usage.getTypeArgumentList(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionParametersFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionParametersFix.java index da0681e3e1d..94c116d31c4 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionParametersFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionParametersFix.java @@ -44,7 +44,7 @@ public class RemoveFunctionParametersFix extends ChangeFunctionSignatureFix { @NotNull @Override public String getText() { - return JetBundle.message("remove.parameter", parameterToRemove.getName().getName()); + return JetBundle.message("remove.parameter", parameterToRemove.getName().asString()); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java index 7dd46e5e6f9..59c7b6fa088 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java @@ -54,9 +54,9 @@ public class RenameParameterToMatchOverriddenMethodFix extends JetIntentionActio } for (CallableDescriptor parameterFromSuperclass : parameterDescriptor.getOverriddenDescriptors()) { if (parameterFromSuperclassName == null) { - parameterFromSuperclassName = parameterFromSuperclass.getName().getName(); + parameterFromSuperclassName = parameterFromSuperclass.getName().asString(); } - else if (!parameterFromSuperclassName.equals(parameterFromSuperclass.getName().getName())) { + else if (!parameterFromSuperclassName.equals(parameterFromSuperclass.getName().asString())) { return false; } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java index 13e05abc668..91a0a1effe0 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java @@ -153,7 +153,7 @@ public class JetNameSuggester { ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(argument); if (classDescriptor != null) { Name className = classDescriptor.getName(); - addName(result, "arrayOf" + StringUtil.capitalize(className.getName()) + "s", validator); + addName(result, "arrayOf" + StringUtil.capitalize(className.asString()) + "s", validator); } } } @@ -173,7 +173,7 @@ public class JetNameSuggester { ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(jetType); if (classDescriptor != null) { Name className = classDescriptor.getName(); - addCamelNames(result, className.getName(), validator); + addCamelNames(result, className.asString(), validator); } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java index 4c194e63cd8..d041c3e9661 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java @@ -84,7 +84,7 @@ public class JetNameValidatorImpl extends JetNameValidator { Collection variants = TipsManager.getVariantsNoReceiver(expression, myBindingContext); for (DeclarationDescriptor variant : variants) { - if (variant.getName().getName().equals(name) && variant instanceof VariableDescriptor) { + if (variant.getName().asString().equals(name) && variant instanceof VariableDescriptor) { result.set(false); return; } 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 bb4a739b123..af2f35d2aff 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java @@ -132,7 +132,7 @@ public class JetChangeInfo implements ChangeInfo { for (int i = 0; i < parameters.size(); i++) { ValueParameterDescriptor oldParameter = parameters.get(i); - map.put(oldParameter.getName().getName(), i); + map.put(oldParameter.getName().asString(), i); } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionPlatformDescriptorImpl.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionPlatformDescriptorImpl.java index 52293387f0c..1a2fa088e39 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionPlatformDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionPlatformDescriptorImpl.java @@ -47,7 +47,7 @@ public class JetFunctionPlatformDescriptorImpl implements JetFunctionPlatformDes @Override public JetParameterInfo fun(ValueParameterDescriptor param) { JetParameter parameter = valueParameters.get(param.getIndex()); - return new JetParameterInfo(param.getIndex(), param.getName().getName(), param.getType(), parameter.getDefaultValue(), parameter.getValOrVarNode()); + return new JetParameterInfo(param.getIndex(), param.getName().asString(), param.getType(), parameter.getDefaultValue(), parameter.getValOrVarNode()); } })); } @@ -55,11 +55,11 @@ public class JetFunctionPlatformDescriptorImpl implements JetFunctionPlatformDes @Override public String getName() { if (funDescriptor instanceof ConstructorDescriptor) - return funDescriptor.getContainingDeclaration().getName().getName(); + return funDescriptor.getContainingDeclaration().getName().asString(); else if (funDescriptor instanceof AnonymousFunctionDescriptor) return ""; else - return funDescriptor.getName().getName(); + return funDescriptor.getName().asString(); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java index e13c82952ef..f7cac7ca7c4 100644 --- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java +++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java @@ -92,8 +92,8 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(module.getProject(), context); JetRunConfiguration configuration = (JetRunConfiguration) settings.getConfiguration(); configuration.setModule(module); - configuration.setName(StringUtil.trimEnd(fqName.getFqName(), "." + PackageClassUtils.getPackageClassName(fqName))); - configuration.setRunClass(fqName.getFqName()); + configuration.setName(StringUtil.trimEnd(fqName.asString(), "." + PackageClassUtils.getPackageClassName(fqName))); + configuration.setRunClass(fqName.asString()); return settings; } @@ -111,7 +111,7 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) { if (existingConfiguration.getType() instanceof JetRunConfigurationType) { JetRunConfiguration jetConfiguration = (JetRunConfiguration)existingConfiguration.getConfiguration(); - if (Comparing.equal(jetConfiguration.getRunClass(), startClassFQName.getFqName())) { + if (Comparing.equal(jetConfiguration.getRunClass(), startClassFQName.asString())) { if (Comparing.equal(location.getModule(), jetConfiguration.getConfigurationModule().getModule())) { return existingConfiguration; } diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java index baff1388452..83e1ea859c4 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java @@ -78,7 +78,7 @@ public class KotlinAnnotatedElementsSearcher extends AnnotatedElementsSearcher { ClassifierDescriptor descriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor(); if (descriptor == null) return; - if (!(DescriptorUtils.getFQName(descriptor).getFqName().equals(annotationFQN))) return; + if (!(DescriptorUtils.getFQName(descriptor).asString().equals(annotationFQN))) return; if (parentOfType instanceof JetClass) { PsiClass lightClass = LightClassUtil.getPsiClass((JetClass) parentOfType); diff --git a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java index cab4b6ee39c..aefbdb7ba67 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java +++ b/idea/src/org/jetbrains/jet/plugin/search/KotlinDirectInheritorsSearcher.java @@ -68,7 +68,7 @@ public class KotlinDirectInheritorsSearcher extends QueryExecutorBase candidateClassNames = ImmutableList.of( kotlinPackageClassFqName, diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java index b74c14560dc..80fe095353b 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java @@ -224,7 +224,7 @@ public class OverrideImplementTest extends LightCodeInsightFixtureTestCase { else { CallableMemberDescriptor candidateToOverride = null; for (CallableMemberDescriptor callable : descriptors) { - if (callable.getName().getName().equals(memberToOverride)) { + if (callable.getName().asString().equals(memberToOverride)) { if (candidateToOverride != null) { throw new IllegalStateException("more then one descriptor with name " + memberToOverride); } diff --git a/idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToStdlibSourceRegressionTest.java b/idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToStdlibSourceRegressionTest.java index 48a7b8d58ec..245b2d82e7f 100644 --- a/idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToStdlibSourceRegressionTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/libraries/NavigateToStdlibSourceRegressionTest.java @@ -22,7 +22,6 @@ import com.intellij.openapi.roots.ContentEntry; import com.intellij.openapi.roots.ModifiableRootModel; import com.intellij.openapi.roots.OrderRootType; import com.intellij.openapi.roots.libraries.Library; -import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; @@ -33,7 +32,6 @@ import com.intellij.testFramework.LightPlatformTestCase; import com.intellij.testFramework.LightProjectDescriptor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor; @@ -98,7 +96,7 @@ public class NavigateToStdlibSourceRegressionTest extends NavigateToLibraryRegre assertEquals(expectedName, ((PsiClass) element).getQualifiedName()); } else if (element instanceof JetClass) { - assertEquals(expectedName, JetPsiUtil.getFQName((JetClass) element).getFqName()); + assertEquals(expectedName, JetPsiUtil.getFQName((JetClass) element).asString()); } else { fail("Navigation element should be JetClass or PsiClass: " + element.getClass() + ", " + element.getText()); diff --git a/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java b/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java index 1bc918937d5..ccfd43a74f1 100644 --- a/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java @@ -74,7 +74,7 @@ public class BuiltInsReferenceResolverTest extends ResolveTestCase { public void testAllReferencesResolved() { BuiltInsReferenceResolver referenceResolver = getProject().getComponent(BuiltInsReferenceResolver.class); for (DeclarationDescriptor descriptor : getAllStandardDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage())) { - if (descriptor instanceof NamespaceDescriptor && "jet".equals(descriptor.getName().getName())) continue; + if (descriptor instanceof NamespaceDescriptor && "jet".equals(descriptor.getName().asString())) continue; assertNotNull("Can't resolve " + descriptor, referenceResolver.resolveStandardLibrarySymbol(descriptor)); } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java index a1cfa977c02..32841871ae1 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java @@ -59,7 +59,7 @@ public class TypeVisitor extends PsiTypeVisitor implements J2KVisitor { IdentifierImpl identifier = new IdentifierImpl(name); if (name.equals("void")) { - myResult = new PrimitiveType(new IdentifierImpl(KotlinBuiltIns.getInstance().getUnit().getName().getName())); + myResult = new PrimitiveType(new IdentifierImpl(KotlinBuiltIns.getInstance().getUnit().getName().asString())); } else if (Node.PRIMITIVE_TYPES.contains(name)) { myResult = new PrimitiveType(new IdentifierImpl(AstUtil.upperFirstCharacter(name))); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java index 8de782ddb18..443c2293a2b 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/Namer.java @@ -191,7 +191,7 @@ public final class Namer { return getRootNamespaceName(); } else { - return descriptor.getName().getName(); + return descriptor.getName().asString(); } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java index 3d8780728c0..fc3e81d99e1 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java @@ -202,7 +202,7 @@ public final class StaticContext { @Nullable public JsName apply(@NotNull DeclarationDescriptor descriptor) { JsScope scope = getEnclosingScope(descriptor); - return scope.declareFreshName(descriptor.getName().getName()); + return scope.declareFreshName(descriptor.getName().asString()); } }; Rule constructorHasTheSameNameAsTheClass = new Rule() { @@ -224,7 +224,7 @@ public final class StaticContext { } PropertyAccessorDescriptor accessorDescriptor = (PropertyAccessorDescriptor) descriptor; - String propertyName = accessorDescriptor.getCorrespondingProperty().getName().getName(); + String propertyName = accessorDescriptor.getCorrespondingProperty().getName().asString(); if (isObjectDeclaration(bindingContext, accessorDescriptor.getCorrespondingProperty())) { return declareName(descriptor, propertyName); } @@ -244,7 +244,7 @@ public final class StaticContext { continue; } String name = getNameForAnnotatedObject(descriptor, annotation); - name = (name != null) ? name : descriptor.getName().getName(); + name = (name != null) ? name : descriptor.getName().asString(); return getEnclosingScope(descriptor).declareName(name); } return null; @@ -257,7 +257,7 @@ public final class StaticContext { return null; } - String name = descriptor.getName().getName(); + String name = descriptor.getName().asString(); if (!isEcma5() || JsDescriptorUtils.isAsPrivate((PropertyDescriptor) descriptor)) { name = Namer.getKotlinBackingFieldName(name); } @@ -272,7 +272,7 @@ public final class StaticContext { if (!(descriptor instanceof FunctionDescriptor)) { return null; } - if (!descriptor.getName().getName().equals("toString")) { + if (!descriptor.getName().asString().equals("toString")) { return null; } if (((FunctionDescriptor) descriptor).getValueParameters().isEmpty()) { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/TranslationContext.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/TranslationContext.java index 4c74149e522..374123af50c 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/TranslationContext.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/TranslationContext.java @@ -163,7 +163,7 @@ public class TranslationContext { //TODO: util @NotNull public JsStringLiteral nameToLiteral(@NotNull Named named) { - return program().getStringLiteral(named.getName().getName()); + return program().getStringLiteral(named.getName().asString()); } @Nullable diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java index 3a27c02e8c7..baa7fed8e0f 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/expression/StringTemplateTranslator.java @@ -96,10 +96,10 @@ public final class StringTemplateTranslator extends AbstractTranslator { return true; } //TODO: this is a hacky optimization, should use some generic approach - if (typeName.getName().equals("String")) { + if (typeName.asString().equals("String")) { return false; } - if (typeName.getName().equals("Int") && resultingExpression != null) { + if (typeName.asString().equals("Int") && resultingExpression != null) { return false; } return true; diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/ArrayForTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/ArrayForTranslator.java index 988625f8cd4..9d5c24db24e 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/ArrayForTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/ArrayForTranslator.java @@ -50,8 +50,8 @@ public final class ArrayForTranslator extends ForTranslator { JetType rangeType = BindingUtils.getTypeForExpression(context.bindingContext(), loopRange); //TODO: better check //TODO: IMPORTANT! - return getClassDescriptorForType(rangeType).getName().getName().equals("Array") - || getClassDescriptorForType(rangeType).getName().getName().equals("IntArray"); + return getClassDescriptorForType(rangeType).getName().asString().equals("Array") + || getClassDescriptorForType(rangeType).getName().asString().equals("IntArray"); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/RangeForTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/RangeForTranslator.java index 48a086959dd..34e01b75e84 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/RangeForTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/expression/foreach/RangeForTranslator.java @@ -48,7 +48,7 @@ public final class RangeForTranslator extends ForTranslator { JetType rangeType = BindingUtils.getTypeForExpression(context.bindingContext(), loopRange); //TODO: better check //TODO: long range? - return getClassDescriptorForType(rangeType).getName().getName().equals("IntRange"); + return getClassDescriptorForType(rangeType).getName().asString().equals("IntRange"); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/initializer/InitializerUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/initializer/InitializerUtils.java index 4e444bbe636..21e7dfc64db 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/initializer/InitializerUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/initializer/InitializerUtils.java @@ -66,10 +66,10 @@ public final class InitializerUtils { public static JsStatement create(Named named, JsExpression value, TranslationContext context) { JsExpression expression; if (context.isEcma5()) { - expression = JsAstUtils.defineProperty(named.getName().getName(), JsAstUtils.createDataDescriptor(value), context); + expression = JsAstUtils.defineProperty(named.getName().asString(), JsAstUtils.createDataDescriptor(value), context); } else { - expression = assignment(new JsNameRef(named.getName().getName(), JsLiteral.THIS), value); + expression = assignment(new JsNameRef(named.getName().asString(), JsLiteral.THIS), value); } return expression.makeStmt(); } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java index 5dbb4d127c7..b17feec05e1 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveBinaryOperationFIF.java @@ -112,7 +112,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory { return RANGE_TO_INTRINSIC; } if (INT_WITH_BIT_OPERATIONS.apply(descriptor)) { - JsBinaryOperator op = BINARY_BITWISE_OPERATIONS.get(descriptor.getName().getName()); + JsBinaryOperator op = BINARY_BITWISE_OPERATIONS.get(descriptor.getName().asString()); if (op != null) { return new PrimitiveBinaryOperationFunctionIntrinsic(op); } @@ -128,7 +128,7 @@ public enum PrimitiveBinaryOperationFIF implements FunctionIntrinsicFactory { token = OperatorConventions.BOOLEAN_OPERATIONS.inverse().get(descriptor.getName()); } if (token == null) { - assert descriptor.getName().getName().equals("xor"); + assert descriptor.getName().asString().equals("xor"); return JsBinaryOperator.BIT_XOR; } return OperatorTable.getBinaryOperator(token); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java index af747aefb74..15de3d52f58 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/factories/PrimitiveUnaryOperationFIF.java @@ -73,7 +73,7 @@ public enum PrimitiveUnaryOperationFIF implements FunctionIntrinsicFactory { Name name = descriptor.getName(); JsUnaryOperator jsOperator = null; - if ("inv".equals(name.getName())) { + if ("inv".equals(name.asString())) { jsOperator = JsUnaryOperator.BIT_NOT; } else { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/NamePredicate.java b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/NamePredicate.java index 3235cbc7722..d309fcffe41 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/NamePredicate.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/NamePredicate.java @@ -36,7 +36,7 @@ public final class NamePredicate implements Predicate { ContainerUtil.map(PrimitiveType.NUMBER_TYPES, new Function() { @Override public String fun(PrimitiveType type) { - return type.getTypeName().getName(); + return type.getTypeName().asString(); } })); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java index 6e12ed2223d..cec4259636f 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java @@ -93,7 +93,7 @@ public final class CallTranslator extends AbstractTranslator { //TODO: private boolean isInvoke() { - return descriptor.getName().getName().equals("invoke"); + return descriptor.getName().asString().equals("invoke"); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java index e7cebde182b..9f95c9a0759 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java @@ -88,7 +88,7 @@ public final class AnnotationsUtils { DeclarationDescriptor annotationDeclaration = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor(); assert annotationDeclaration != null : "Annotation supposed to have a declaration"; - return DescriptorUtils.getFQName(annotationDeclaration).getFqName(); + return DescriptorUtils.getFQName(annotationDeclaration).asString(); } public static boolean isNativeObject(@NotNull DeclarationDescriptor descriptor) { From 7761d7d646471273d70c72bdebc6cac630603da9 Mon Sep 17 00:00:00 2001 From: Martin Lau Date: Wed, 22 May 2013 12:05:05 +1000 Subject: [PATCH 31/92] Added scanning for annotations.xml entries within maven dependencies --- libraries/tools/kotlin-maven-plugin/pom.xml | 7 +- .../kotlin/maven/KotlinCompileMojoBase.java | 77 +++++++++++++++++++ 2 files changed, 83 insertions(+), 1 deletion(-) diff --git a/libraries/tools/kotlin-maven-plugin/pom.xml b/libraries/tools/kotlin-maven-plugin/pom.xml index fdbd1c3d930..548c9a40337 100644 --- a/libraries/tools/kotlin-maven-plugin/pom.xml +++ b/libraries/tools/kotlin-maven-plugin/pom.xml @@ -20,7 +20,12 @@ maven-plugin - + + org.apache.maven + maven-core + ${maven.version} + + org.apache.maven maven-plugin-api ${maven.version} diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java index 55d7324d7d7..79086a63022 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java @@ -18,10 +18,12 @@ package org.jetbrains.kotlin.maven; import com.google.common.base.Joiner; import com.intellij.openapi.util.text.StringUtil; +import org.apache.maven.artifact.Artifact; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugin.logging.Log; +import org.apache.maven.project.MavenProject; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.cli.common.CLICompiler; import org.jetbrains.jet.cli.common.CompilerArguments; @@ -34,12 +36,17 @@ import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; import java.io.File; +import java.io.IOException; import java.lang.reflect.Field; import java.net.URL; import java.net.URLClassLoader; import java.util.ArrayList; import java.util.Arrays; +import java.util.Enumeration; import java.util.List; +import java.util.Set; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; import static com.intellij.openapi.util.text.StringUtil.join; @@ -81,7 +88,17 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { // TODO not sure why this doesn't work :( // * @parameter default-value="$(project.basedir}/src/main/resources" + /** + * @parameter default-value="${project}" + * @required + * @readonly + */ + public MavenProject project; + /** + * @parameter default-value="true" + */ + public boolean scanForAnnotations; /** * Project classpath. @@ -296,6 +313,15 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { } } } + + if (scanForAnnotations) { + for (String path : scanAnnotations(log)) { + if (!list.contains(path)) { + list.add(path); + } + } + } + return join(list, File.pathSeparator); } @@ -320,4 +346,55 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { throw new RuntimeException("Could not get jdk annotations from Kotlin plugin`s classpath"); } + + protected List scanAnnotations(Log log) { + final List annotations = new ArrayList(); + + final Set artifacts = project.getArtifacts(); + for (Artifact artifact : artifacts) { + final File file = artifact.getFile(); + if (containsAnnotations(file, log)) { + log.info("Discovered kotlin annotations in: " + file); + try { + annotations.add(file.getCanonicalPath()); + } + catch (IOException e) { + log.warn("Error extracting canonical path from: " + file, e); + } + } + } + + return annotations; + } + + protected boolean containsAnnotations(File file, Log log) { + log.debug("Scanning for kotlin annotations in " + file); + + ZipFile zipFile = null; + try { + zipFile = new ZipFile(file); + + final Enumeration entries = zipFile.entries(); + while (entries.hasMoreElements()) { + String name = entries.nextElement().getName(); + if (name.endsWith("/annotations.xml")) { + return true; + } + } + } + catch (IOException e) { + log.warn("Error reading contents of jar: " + file, e); + } + finally { + if (zipFile != null) { + try { + zipFile.close(); + } + catch (IOException e) { + log.warn("Error closing: " + zipFile, e); + } + } + } + return false; + } } From ba90f07c8dbbd783dd7966c5bd9e159e195a6ff6 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 22 May 2013 20:52:09 +0400 Subject: [PATCH 32/92] Fixed compilation after renaming Name.getName() to asString() --- .../jetbrains/kotlin/doc/model/KotlinModel.kt | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KotlinModel.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KotlinModel.kt index 95e55797415..299c8512e6a 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KotlinModel.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KotlinModel.kt @@ -59,7 +59,7 @@ fun qualifiedName(descriptor: DeclarationDescriptor?): String { return "" } else { val parent = containerName(descriptor) - var name = descriptor.getName()?.getName() ?: "" + var name = descriptor.getName()?.asString() ?: "" if (name.startsWith("<")) { name = "" } @@ -385,7 +385,7 @@ class KModel(val context: BindingContext, val config: KDocConfig, val sourceDirs val descriptors = scope.getAllDescriptors() for (descriptor in descriptors) { if (descriptor is PropertyDescriptor) { - val name = descriptor.getName().getName() + val name = descriptor.getName().asString() val returnType = getType(descriptor.getReturnType()) if (returnType != null) { val receiver = descriptor.getReceiverParameter() @@ -413,7 +413,7 @@ class KModel(val context: BindingContext, val config: KDocConfig, val sourceDirs protected fun createFunction(owner: KClassOrPackage, descriptor: CallableDescriptor): KFunction? { val returnType = getType(descriptor.getReturnType()) if (returnType != null) { - val name = descriptor.getName().getName() + val name = descriptor.getName().asString() val parameters = ArrayList() val params = descriptor.getValueParameters() for (param in params) { @@ -450,7 +450,7 @@ class KModel(val context: BindingContext, val config: KDocConfig, val sourceDirs } protected fun createTypeParameter(descriptor: TypeParameterDescriptor): KTypeParameter? { - val name = descriptor.getName().getName() + val name = descriptor.getName().asString() val answer = KTypeParameter(name, descriptor, this) configureComments(answer, descriptor) return answer @@ -459,7 +459,7 @@ class KModel(val context: BindingContext, val config: KDocConfig, val sourceDirs protected fun createParameter(descriptor: ValueParameterDescriptor): KParameter? { val returnType = getType(descriptor.getReturnType()) if (returnType != null) { - val name = descriptor.getName().getName() + val name = descriptor.getName().asString() val answer = KParameter(descriptor, name, returnType) configureComments(answer, descriptor) return answer @@ -704,7 +704,7 @@ $highlight""" } fun getClass(classElement: ClassDescriptor): KClass? { - val name = classElement.getName().getName() + val name = classElement.getName().asString() var dec: DeclarationDescriptor? = classElement.getContainingDeclaration() while (dec != null) { val container = dec @@ -958,7 +958,7 @@ class KPackage(model: KModel, val descriptor: NamespaceDescriptor, fun toString() = "KPackage($name)" fun getClass(descriptor: ClassDescriptor): KClass { - val name = descriptor.getName().getName() + val name = descriptor.getName().asString() var created = false val klass = classMap.getOrPut(name) { created = true @@ -1074,7 +1074,7 @@ class KClass( val sourceInfo: SourceInfo?) : KClassOrPackage(pkg.model, descriptor), Comparable { - val simpleName = descriptor.getName().getName() + val simpleName = descriptor.getName().asString() var group: String = "Other" var annotations: List = arrayList() var typeParameters: MutableList = arrayList() @@ -1130,7 +1130,7 @@ class KClass( return $url } - public val name: String = pkg.qualifiedName(descriptor.getName().getName()) + public val name: String = pkg.qualifiedName(descriptor.getName().asString()) public val packageName: String = pkg.name From 3299957c0c85fe3548fb43f7883bc53f1b82d9aa Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 20:31:26 +0400 Subject: [PATCH 33/92] Support jps.kotlin.home --- compiler/util/src/org/jetbrains/jet/utils/PathUtil.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java index e17331e4f12..e895d7b83b8 100644 --- a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java +++ b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java @@ -49,6 +49,13 @@ public class PathUtil { @NotNull public static KotlinPaths getKotlinPathsForJpsPluginOrJpsTests() { + // When JPS is run on TeamCity, it can not rely on Kotlin plugin layout, + // so the path to Kotlin is specified in a system property + String jpsKotlinHome = System.getProperty("jps.kotlin.home"); + if (jpsKotlinHome != null) { + return new KotlinPathsFromHomeDir(new File(jpsKotlinHome)); + } + if ("true".equalsIgnoreCase(System.getProperty("kotlin.jps.tests"))) { return getKotlinPathsForDistDirectory(); } From 1a5c9430572eef7e390ce45168a5f535bb919c65 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 27 May 2013 13:55:05 +0400 Subject: [PATCH 34/92] Support jps.kotlin.home --- compiler/util/src/org/jetbrains/jet/utils/PathUtil.java | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java index e895d7b83b8..cbafebff153 100644 --- a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java +++ b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java @@ -44,18 +44,17 @@ public class PathUtil { @NotNull public static KotlinPaths getKotlinPathsForJpsPlugin() { - return new KotlinPathsFromHomeDir(getCompilerPathForJpsPlugin()); - } - - @NotNull - public static KotlinPaths getKotlinPathsForJpsPluginOrJpsTests() { // When JPS is run on TeamCity, it can not rely on Kotlin plugin layout, // so the path to Kotlin is specified in a system property String jpsKotlinHome = System.getProperty("jps.kotlin.home"); if (jpsKotlinHome != null) { return new KotlinPathsFromHomeDir(new File(jpsKotlinHome)); } + return new KotlinPathsFromHomeDir(getCompilerPathForJpsPlugin()); + } + @NotNull + public static KotlinPaths getKotlinPathsForJpsPluginOrJpsTests() { if ("true".equalsIgnoreCase(System.getProperty("kotlin.jps.tests"))) { return getKotlinPathsForDistDirectory(); } From e96cf045ddba580fb5e5e9c997b5153bfbf76468 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Mon, 27 May 2013 14:38:05 +0400 Subject: [PATCH 35/92] KT-3652: Char is converted to Int when used inside string interpolation #KT-3652 Fixed --- .../backend/src/org/jetbrains/jet/codegen/AsmUtil.java | 4 ++-- .../src/org/jetbrains/jet/codegen/ExpressionCodegen.java | 3 ++- .../org/jetbrains/jet/codegen/intrinsics/ToString.java | 2 +- compiler/testData/codegen/box/strings/kt3652.kt | 9 +++++++++ .../codegen/generated/BlackBoxCodegenTestGenerated.java | 9 +++++++-- 5 files changed, 21 insertions(+), 6 deletions(-) create mode 100644 compiler/testData/codegen/box/strings/kt3652.kt diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 76d717a323b..8a818ac3f6d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -354,8 +354,8 @@ public class AsmUtil { v.invokevirtual("java/lang/StringBuilder", "append", "(" + type.getDescriptor() + ")Ljava/lang/StringBuilder;"); } - public static StackValue genToString(InstructionAdapter v, StackValue receiver) { - Type type = stringValueOfOrStringBuilderAppendType(receiver.type); + public static StackValue genToString(InstructionAdapter v, StackValue receiver, Type receiverType) { + Type type = stringValueOfOrStringBuilderAppendType(receiverType); receiver.put(type, v); v.invokestatic("java/lang/String", "valueOf", "(" + type.getDescriptor() + ")Ljava/lang/String;"); return StackValue.onStack(JAVA_STRING_TYPE); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index adb1cf703f6..46b869544f4 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1173,7 +1173,8 @@ public class ExpressionCodegen extends JetVisitor implem JetStringTemplateEntry[] entries = expression.getEntries(); if (entries.length == 1 && entries[0] instanceof JetStringTemplateEntryWithExpression) { - return genToString(v, gen(entries[0].getExpression())); + JetExpression expr = entries[0].getExpression(); + return genToString(v, gen(expr), expressionType(expr)); } for (JetStringTemplateEntry entry : entries) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java index e9ba927ae5f..be44473606d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java @@ -40,6 +40,6 @@ public class ToString implements IntrinsicMethod { StackValue receiver, @NotNull GenerationState state ) { - return genToString(v, receiver); + return genToString(v, receiver, receiver.type); } } diff --git a/compiler/testData/codegen/box/strings/kt3652.kt b/compiler/testData/codegen/box/strings/kt3652.kt new file mode 100644 index 00000000000..f9e678089b8 --- /dev/null +++ b/compiler/testData/codegen/box/strings/kt3652.kt @@ -0,0 +1,9 @@ +fun box(): String { + var a = 'a' + + if ("${a++}x" != "ax") return "fail1" + + if ("${a++}" != "b") return "fail2" + + return "OK" +} diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java index 2d7d964b432..aa30ff43a69 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java @@ -1546,8 +1546,8 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { doTest("compiler/testData/codegen/box/defaultArguments/constructor/kt2852.kt"); } - } - + } + @TestMetadata("compiler/testData/codegen/box/defaultArguments/function") public static class Function extends AbstractBlackBoxCodegenTest { public void testAllFilesPresentInFunction() throws Exception { @@ -3686,6 +3686,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { doTest("compiler/testData/codegen/box/strings/ea35743.kt"); } + @TestMetadata("kt3652.kt") + public void testKt3652() throws Exception { + doTest("compiler/testData/codegen/box/strings/kt3652.kt"); + } + @TestMetadata("kt881.kt") public void testKt881() throws Exception { doTest("compiler/testData/codegen/box/strings/kt881.kt"); From d4fc814d764bb332d0192e8f42a1b102d0c4d47e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Sapalski?= Date: Mon, 22 Apr 2013 15:26:54 +0200 Subject: [PATCH 36/92] Quickfix for NOTHING_TO_OVERRIDE: add function to one of supertypes. --- .../jetbrains/jet/plugin/JetBundle.properties | 7 +- .../JetAddFunctionToClassifierAction.java | 184 ++++++++++++++++++ .../DescriptorToDeclarationUtil.java | 7 +- .../quickfix/AddFunctionToSupertypeFix.java | 171 ++++++++++++++++ .../jet/plugin/quickfix/QuickFixes.java | 1 + .../nothingToOverride/afterAddFunction.kt | 8 + .../afterAddFunctionAbstractClass.kt | 7 + .../afterAddFunctionNoBody.kt | 8 + .../afterAddFunctionNonUnitReturnType.kt | 9 + .../afterAddFunctionTrait.kt | 7 + .../afterAddFunctionTwoSuperclasses.kt | 10 + .../afterAddFunctionTwoTraits.kt | 8 + .../afterNoOpenSuperFunction.kt | 11 -- .../nothingToOverride/beforeAddFunction.kt | 6 + .../beforeAddFunctionAbstractClass.kt | 6 + .../beforeAddFunctionNoBody.kt | 5 + .../beforeAddFunctionNonUnitReturnType.kt | 6 + .../beforeAddFunctionTrait.kt | 6 + .../beforeAddFunctionTwoSuperclasses.kt | 8 + .../beforeAddFunctionTwoTraits.kt | 6 + .../beforeNoOpenSuperFunction.kt | 1 + .../quickfix/QuickFixTestGenerated.java | 35 ++++ 22 files changed, 504 insertions(+), 13 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunction.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionAbstractClass.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNoBody.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNonUnitReturnType.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTrait.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoSuperclasses.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoTraits.kt delete mode 100644 idea/testData/quickfix/override/nothingToOverride/afterNoOpenSuperFunction.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunction.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionAbstractClass.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNoBody.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNonUnitReturnType.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTrait.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoSuperclasses.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoTraits.kt diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index 868da4e6b67..9536b7af1f7 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -209,4 +209,9 @@ property.is.implemented.header=Is implemented in
property.is.overridden.header=Is overridden in
navigation.title.overriding.property=Choose Implementation of {0} -navigation.findUsages.title.overriding.property=Overriding properties of {0} \ No newline at end of file +navigation.findUsages.title.overriding.property=Overriding properties of {0} +add.function.to.supertype.family=Add Function to Supertype +add.function.to.supertype.action.multiple=Add function to supertype... +add.function.to.type.action.single=Add ''{0}'' to ''{1}'' +add.function.to.type.action=Add function to type +add.function.to.type.action.type.chooser=Choose type... diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java new file mode 100644 index 00000000000..f9f7ff26f13 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/actions/JetAddFunctionToClassifierAction.java @@ -0,0 +1,184 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.actions; + +import com.intellij.codeInsight.hint.QuestionAction; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.command.CommandProcessor; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.ui.popup.JBPopupFactory; +import com.intellij.openapi.ui.popup.ListPopupStep; +import com.intellij.openapi.ui.popup.PopupStep; +import com.intellij.openapi.ui.popup.util.BaseListPopupStep; +import com.intellij.psi.PsiDocumentManager; +import com.intellij.psi.PsiElement; +import com.intellij.util.PlatformIcons; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassKind; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.Modality; +import org.jetbrains.jet.lang.psi.JetClass; +import org.jetbrains.jet.lang.psi.JetClassBody; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils; +import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil; +import org.jetbrains.jet.plugin.codeInsight.ReferenceToClassesShortening; + +import javax.swing.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Changes method signature to one of provided signatures. + * Based on {@link JetAddImportAction} + */ +public class JetAddFunctionToClassifierAction implements QuestionAction { + private final List functionsToAdd; + private final Project project; + private final Editor editor; + private final BindingContext bindingContext; + + /** + * @param project Project where action takes place. + * @param editor Editor where modification should be done. + * @param bindingContext BindingContext to be used for finding type declarations. + * @param functionsToAdd List of possible functions to add. + */ + public JetAddFunctionToClassifierAction( + @NotNull Project project, + @NotNull Editor editor, + @NotNull BindingContext bindingContext, + @NotNull List functionsToAdd + ) { + this.project = project; + this.editor = editor; + this.bindingContext = bindingContext; + this.functionsToAdd = new ArrayList(functionsToAdd); + } + + private static void addFunction( + @NotNull final Project project, + @NotNull final ClassDescriptor typeDescriptor, + @NotNull final FunctionDescriptor functionDescriptor, + @NotNull BindingContext bindingContext + ) { + final String signatureString = CodeInsightUtils.createFunctionSignatureStringFromDescriptor( + functionDescriptor, + /* shortTypeNames = */ false); + + PsiDocumentManager.getInstance(project).commitAllDocuments(); + + final JetClass classifierDeclaration = (JetClass) DescriptorToDeclarationUtil.getDeclaration(project, typeDescriptor, bindingContext); + CommandProcessor.getInstance().executeCommand(project, new Runnable() { + @Override + public void run() { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + JetClassBody body = classifierDeclaration.getBody(); + if (body == null) { + PsiElement whitespaceBefore = classifierDeclaration.add(JetPsiFactory.createWhiteSpace(project)); + body = (JetClassBody) classifierDeclaration.addAfter(JetPsiFactory.createEmptyClassBody(project), whitespaceBefore); + classifierDeclaration.addAfter(JetPsiFactory.createNewLine(project), body); + } + + String functionBody = ""; + if (typeDescriptor.getKind() != ClassKind.TRAIT && functionDescriptor.getModality() != Modality.ABSTRACT) { + functionBody = "{}"; + JetType returnType = functionDescriptor.getReturnType(); + if (returnType == null || !KotlinBuiltIns.getInstance().isUnit(returnType)) { + functionBody = "{ throw UnsupportedOperationException() }"; + } + } + JetNamedFunction functionElement = JetPsiFactory.createFunction(project, signatureString + functionBody); + PsiElement anchor = body.getRBrace(); + JetNamedFunction insertedFunctionElement = (JetNamedFunction) body.addBefore(functionElement, anchor); + + ReferenceToClassesShortening.compactReferenceToClasses(Collections.singletonList(insertedFunctionElement)); + } + }); + } + }, JetBundle.message("add.function.to.type.action"), null); + } + + @Override + public boolean execute() { + if (functionsToAdd.isEmpty()) { + return false; + } + + if (functionsToAdd.size() == 1 || !editor.getComponent().isShowing()) { + addFunction(functionsToAdd.get(0)); + } + else { + chooseFunctionAndAdd(); + } + + return true; + } + + private void chooseFunctionAndAdd() { + JBPopupFactory.getInstance().createListPopup(getFunctionPopup()).showInBestPositionFor(editor); + } + + private ListPopupStep getFunctionPopup() { + return new BaseListPopupStep( + JetBundle.message("add.function.to.type.action.type.chooser"), functionsToAdd) { + @Override + public boolean isAutoSelectionEnabled() { + return false; + } + + @Override + public PopupStep onChosen(FunctionDescriptor selectedValue, boolean finalChoice) { + if (finalChoice) { + addFunction(selectedValue); + } + return FINAL_CHOICE; + } + + @Override + public Icon getIconFor(FunctionDescriptor aValue) { + return PlatformIcons.FUNCTION_ICON; + } + + @NotNull + @Override + public String getTextFor(FunctionDescriptor functionDescriptor) { + ClassDescriptor type = (ClassDescriptor) functionDescriptor.getContainingDeclaration(); + return JetBundle.message("add.function.to.type.action.single", + CodeInsightUtils.createFunctionSignatureStringFromDescriptor( + functionDescriptor, + /* shortTypeNames = */ true), + type.getName().toString()); + } + }; + } + + private void addFunction(FunctionDescriptor functionToAdd) { + addFunction(project, (ClassDescriptor) functionToAdd.getContainingDeclaration(), + functionToAdd, bindingContext); + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/DescriptorToDeclarationUtil.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/DescriptorToDeclarationUtil.java index ca707dba1e4..d914eba74f2 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/DescriptorToDeclarationUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/DescriptorToDeclarationUtil.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.plugin.codeInsight; +import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.JetFile; @@ -30,11 +31,15 @@ public final class DescriptorToDeclarationUtil { } public static PsiElement getDeclaration(JetFile file, DeclarationDescriptor descriptor, BindingContext bindingContext) { + return getDeclaration(file.getProject(), descriptor, bindingContext); + } + + public static PsiElement getDeclaration(Project project, DeclarationDescriptor descriptor, BindingContext bindingContext) { Collection elements = BindingContextUtils.descriptorToDeclarations(bindingContext, descriptor); if (elements.isEmpty()) { BuiltInsReferenceResolver libraryReferenceResolver = - file.getProject().getComponent(BuiltInsReferenceResolver.class); + project.getComponent(BuiltInsReferenceResolver.class); elements = libraryReferenceResolver.resolveStandardLibrarySymbol(descriptor); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java new file mode 100644 index 00000000000..05844b5f937 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java @@ -0,0 +1,171 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.quickfix; + +import com.google.common.collect.Lists; +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.openapi.command.CommandProcessor; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiFile; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamedFunction; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.actions.JetAddFunctionToClassifierAction; +import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; +import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils; + +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +public class AddFunctionToSupertypeFix extends JetHintAction { + private final List functionsToAdd; + + public AddFunctionToSupertypeFix(JetNamedFunction element) { + super(element); + functionsToAdd = generateFunctionsToAdd(element); + } + + private static List generateFunctionsToAdd(JetNamedFunction functionElement) { + BindingContext context = KotlinCacheManagerUtil.getDeclarationsFromProject(functionElement).getBindingContext(); + + FunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, functionElement); + if (functionDescriptor == null) return Collections.emptyList(); + + DeclarationDescriptor containingDeclaration = functionDescriptor.getContainingDeclaration(); + if (!(containingDeclaration instanceof ClassDescriptor)) return Collections.emptyList(); + + List functions = Lists.newArrayList(); + ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; + // TODO: filter out impossible supertypes (for example when argument's type isn't visible in a superclass). + for (ClassDescriptor supertypeDescriptor : getSupertypes(classDescriptor)) { + if (KotlinBuiltIns.getInstance().isAny(supertypeDescriptor.getDefaultType())) continue; + functions.add(generateFunctionSignatureForType(functionDescriptor, supertypeDescriptor)); + } + return functions; + } + + private static List getSupertypes(ClassDescriptor classDescriptor) { + List supertypes = Lists.newArrayList(TypeUtils.getAllSupertypes(classDescriptor.getDefaultType())); + Collections.sort(supertypes, new Comparator() { + @Override + public int compare(JetType o1, JetType o2) { + if (o1.equals(o2)) { + return 0; + } + if (JetTypeChecker.INSTANCE.isSubtypeOf(o1, o2)) { + return -1; + } + if (JetTypeChecker.INSTANCE.isSubtypeOf(o2, o1)) { + return 1; + } + return o1.toString().compareTo(o2.toString()); + } + }); + List supertypesDescriptors = Lists.newArrayList(); + for (JetType supertype : supertypes) { + supertypesDescriptors.add(DescriptorUtils.getClassDescriptorForType(supertype)); + } + return supertypesDescriptors; + } + + private static FunctionDescriptor generateFunctionSignatureForType( + FunctionDescriptor functionDescriptor, + ClassDescriptor typeDescriptor + ) { + // TODO: support for generics. + Modality modality = typeDescriptor.getModality(); + if (typeDescriptor.getKind() == ClassKind.TRAIT) { + modality = Modality.OPEN; + } + return functionDescriptor.copy( + typeDescriptor, + modality, + functionDescriptor.getVisibility(), + CallableMemberDescriptor.Kind.DECLARATION, + /* copyOverrides = */ false); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + return super.isAvailable(project, editor, file) && !functionsToAdd.isEmpty(); + } + + @Override + public boolean showHint(Editor editor) { + return false; + } + + @NotNull + @Override + public String getText() { + if (functionsToAdd.size() == 1) { + FunctionDescriptor newFunction = functionsToAdd.get(0); + ClassDescriptor supertype = (ClassDescriptor) newFunction.getContainingDeclaration(); + return JetBundle.message("add.function.to.type.action.single", + CodeInsightUtils.createFunctionSignatureStringFromDescriptor(newFunction, /* shortTypeNames */ true), + supertype.getName().toString()); + } + else { + return JetBundle.message("add.function.to.supertype.action.multiple"); + } + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("add.function.to.supertype.family"); + } + + @Override + protected void invoke(@NotNull final Project project, final Editor editor, JetFile file) { + CommandProcessor.getInstance().runUndoTransparentAction(new Runnable() { + @Override + public void run() { + createAction(project, editor).execute(); + } + }); + } + + @NotNull + private JetAddFunctionToClassifierAction createAction(Project project, Editor editor) { + BindingContext bindingContext = KotlinCacheManagerUtil.getDeclarationsFromProject(element).getBindingContext(); + return new JetAddFunctionToClassifierAction(project, editor, bindingContext, functionsToAdd); + } + + public static JetIntentionActionFactory createFactory() { + return new JetIntentionActionFactory() { + @Nullable + @Override + public IntentionAction createAction(Diagnostic diagnostic) { + JetNamedFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetNamedFunction.class); + return function == null ? null : new AddFunctionToSupertypeFix(function); + } + }; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index 9369f5b330b..be8f7fb5b30 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -91,6 +91,7 @@ public class QuickFixes { factories.put(NOTHING_TO_OVERRIDE, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OVERRIDE_KEYWORD)); factories.put(NOTHING_TO_OVERRIDE, ChangeMemberFunctionSignatureFix.createFactory()); + factories.put(NOTHING_TO_OVERRIDE, AddFunctionToSupertypeFix.createFactory()); factories.put(VIRTUAL_MEMBER_HIDDEN, AddModifierFix.createFactory(OVERRIDE_KEYWORD)); factories.put(USELESS_CAST_STATIC_ASSERT_IS_FINE, ReplaceOperationInBinaryExpressionFix.createChangeCastToStaticAssertFactory()); diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunction.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunction.kt new file mode 100644 index 00000000000..63779357b90 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunction.kt @@ -0,0 +1,8 @@ +// "Add 'open fun f()' to 'A'" "true" +open class A { + open fun f() { + } +} +class B : A() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionAbstractClass.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionAbstractClass.kt new file mode 100644 index 00000000000..49ccd13b9be --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionAbstractClass.kt @@ -0,0 +1,7 @@ +// "Add 'abstract fun f()' to 'A'" "true" +abstract class A { + abstract fun f() +} +class B : A() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNoBody.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNoBody.kt new file mode 100644 index 00000000000..dfa3a7dee99 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNoBody.kt @@ -0,0 +1,8 @@ +// "Add 'open fun f()' to 'A'" "true" +trait A +{ + open fun f() +} +class B : A { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNonUnitReturnType.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNonUnitReturnType.kt new file mode 100644 index 00000000000..cda0f209598 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionNonUnitReturnType.kt @@ -0,0 +1,9 @@ +// "Add 'open fun f(): Int' to 'A'" "true" +open class A { + open fun f(): Int { + throw UnsupportedOperationException() + } +} +class B : A() { + override fun f(): Int = 5 +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTrait.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTrait.kt new file mode 100644 index 00000000000..92dda9599a1 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTrait.kt @@ -0,0 +1,7 @@ +// "Add 'open fun f()' to 'A'" "true" +trait A { + open fun f() +} +class B : A { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoSuperclasses.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoSuperclasses.kt new file mode 100644 index 00000000000..d151ba2fd15 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoSuperclasses.kt @@ -0,0 +1,10 @@ +// "Add function to supertype..." "true" +open class A { +} +open class B : A() { + open fun f() { + } +} +class C : B() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoTraits.kt b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoTraits.kt new file mode 100644 index 00000000000..32dcc19553a --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterAddFunctionTwoTraits.kt @@ -0,0 +1,8 @@ +// "Add function to supertype..." "true" +trait A { + open fun foo() +} +trait B {} +class C: A, B { + override fun foo() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/afterNoOpenSuperFunction.kt b/idea/testData/quickfix/override/nothingToOverride/afterNoOpenSuperFunction.kt deleted file mode 100644 index b42fbdf5f47..00000000000 --- a/idea/testData/quickfix/override/nothingToOverride/afterNoOpenSuperFunction.kt +++ /dev/null @@ -1,11 +0,0 @@ -// "Change function signature to 'override fun f(a: Int)'" "false" -// ERROR: 'f' overrides nothing -// ACTION: Remove 'override' modifier -open class A { - open fun foo() {} - fun f(a: Int) {} -} - -class B : A(){ - override fun f(a: String) {} -} diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunction.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunction.kt new file mode 100644 index 00000000000..3136907d089 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunction.kt @@ -0,0 +1,6 @@ +// "Add 'open fun f()' to 'A'" "true" +open class A { +} +class B : A() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionAbstractClass.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionAbstractClass.kt new file mode 100644 index 00000000000..f6b022c0513 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionAbstractClass.kt @@ -0,0 +1,6 @@ +// "Add 'abstract fun f()' to 'A'" "true" +abstract class A { +} +class B : A() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNoBody.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNoBody.kt new file mode 100644 index 00000000000..705d1af6ec4 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNoBody.kt @@ -0,0 +1,5 @@ +// "Add 'open fun f()' to 'A'" "true" +trait A +class B : A { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNonUnitReturnType.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNonUnitReturnType.kt new file mode 100644 index 00000000000..8f76628cbb3 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNonUnitReturnType.kt @@ -0,0 +1,6 @@ +// "Add 'open fun f(): Int' to 'A'" "true" +open class A { +} +class B : A() { + override fun f(): Int = 5 +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTrait.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTrait.kt new file mode 100644 index 00000000000..3d2c4024c5b --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTrait.kt @@ -0,0 +1,6 @@ +// "Add 'open fun f()' to 'A'" "true" +trait A { +} +class B : A { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoSuperclasses.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoSuperclasses.kt new file mode 100644 index 00000000000..d717c14cf3f --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoSuperclasses.kt @@ -0,0 +1,8 @@ +// "Add function to supertype..." "true" +open class A { +} +open class B : A() { +} +class C : B() { + override fun f() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoTraits.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoTraits.kt new file mode 100644 index 00000000000..48498de2050 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoTraits.kt @@ -0,0 +1,6 @@ +// "Add function to supertype..." "true" +trait A {} +trait B {} +class C: A, B { + override fun foo() {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeNoOpenSuperFunction.kt b/idea/testData/quickfix/override/nothingToOverride/beforeNoOpenSuperFunction.kt index b42fbdf5f47..1ae08772709 100644 --- a/idea/testData/quickfix/override/nothingToOverride/beforeNoOpenSuperFunction.kt +++ b/idea/testData/quickfix/override/nothingToOverride/beforeNoOpenSuperFunction.kt @@ -1,5 +1,6 @@ // "Change function signature to 'override fun f(a: Int)'" "false" // ERROR: 'f' overrides nothing +// ACTION: Add 'open fun f(a: String)' to 'A' // ACTION: Remove 'override' modifier open class A { open fun foo() {} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index d35d22f475b..d5fc32546e1 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -866,6 +866,41 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { @TestMetadata("idea/testData/quickfix/override/nothingToOverride") public static class NothingToOverride extends AbstractQuickFixTest { + @TestMetadata("beforeAddFunction.kt") + public void testAddFunction() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunction.kt"); + } + + @TestMetadata("beforeAddFunctionAbstractClass.kt") + public void testAddFunctionAbstractClass() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionAbstractClass.kt"); + } + + @TestMetadata("beforeAddFunctionNoBody.kt") + public void testAddFunctionNoBody() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNoBody.kt"); + } + + @TestMetadata("beforeAddFunctionNonUnitReturnType.kt") + public void testAddFunctionNonUnitReturnType() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionNonUnitReturnType.kt"); + } + + @TestMetadata("beforeAddFunctionTrait.kt") + public void testAddFunctionTrait() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTrait.kt"); + } + + @TestMetadata("beforeAddFunctionTwoSuperclasses.kt") + public void testAddFunctionTwoSuperclasses() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoSuperclasses.kt"); + } + + @TestMetadata("beforeAddFunctionTwoTraits.kt") + public void testAddFunctionTwoTraits() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddFunctionTwoTraits.kt"); + } + @TestMetadata("beforeAddParameter.kt") public void testAddParameter() throws Exception { doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddParameter.kt"); From cacb4b26e4f73b194e6bedeb5a40a7f1c1036403 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Sapalski?= Date: Sat, 2 Mar 2013 15:08:00 +0100 Subject: [PATCH 37/92] Support for generic classes in quickfix for NOTHING_TO_OVERRIDE --- .../lang/descriptors/ValueParameterDescriptor.java | 3 ++- .../impl/ValueParameterDescriptorImpl.java | 5 +++-- .../quickfix/ChangeMemberFunctionSignatureFix.java | 13 +++++++++---- .../afterAddParameterGenericClass.kt | 8 ++++++++ .../afterSwapParametersGenericClass.kt | 8 ++++++++ .../beforeAddParameterGenericClass.kt | 8 ++++++++ .../beforeSwapParametersGenericClass.kt | 8 ++++++++ .../jet/plugin/quickfix/QuickFixTestGenerated.java | 10 ++++++++++ 8 files changed, 56 insertions(+), 7 deletions(-) create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterAddParameterGenericClass.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/afterSwapParametersGenericClass.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeAddParameterGenericClass.kt create mode 100644 idea/testData/quickfix/override/nothingToOverride/beforeSwapParametersGenericClass.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java index 8b01d2f35e7..262a44541d3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.annotations.Annotated; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import java.util.Set; @@ -57,7 +58,7 @@ public interface ValueParameterDescriptor extends VariableDescriptor, Annotated ValueParameterDescriptor getOriginal(); @NotNull - ValueParameterDescriptor copy(DeclarationDescriptor newOwner); + ValueParameterDescriptor copy(DeclarationDescriptor newOwner, Name newName); /** * Parameter p1 overrides p2 iff diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ValueParameterDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ValueParameterDescriptorImpl.java index 2e52abd0de7..464f1bad64c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ValueParameterDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/ValueParameterDescriptorImpl.java @@ -111,6 +111,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme } @Nullable + @Override public JetType getVarargElementType() { return varargElementType; } @@ -139,8 +140,8 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme @NotNull @Override - public ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner) { - return new ValueParameterDescriptorImpl(newOwner, index, Lists.newArrayList(getAnnotations()), getName(), getType(), hasDefaultValue, varargElementType); + public ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner, @NotNull Name newName) { + return new ValueParameterDescriptorImpl(newOwner, index, Lists.newArrayList(getAnnotations()), newName, getType(), declaresDefaultValue(), varargElementType); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeMemberFunctionSignatureFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeMemberFunctionSignatureFix.java index 21e14bf9684..92baa0490f1 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeMemberFunctionSignatureFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeMemberFunctionSignatureFix.java @@ -34,11 +34,11 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.VisibilityUtil; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.actions.JetChangeFunctionSignatureAction; @@ -187,7 +187,13 @@ public class ChangeMemberFunctionSignatureFix extends JetHintAction { + fun f(a: Int, b: R) +} + +class B : A { + override fun f(a: Int, x: T) {} +} diff --git a/idea/testData/quickfix/override/nothingToOverride/afterSwapParametersGenericClass.kt b/idea/testData/quickfix/override/nothingToOverride/afterSwapParametersGenericClass.kt new file mode 100644 index 00000000000..285b28cb7a3 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/afterSwapParametersGenericClass.kt @@ -0,0 +1,8 @@ +// "Change function signature to 'override fun f(y: S, x: List>)'" "true" +trait A { + fun f(a: Q, b: List>) +} + +class B : A { + override fun f(y: S, x: List>) {} +} diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeAddParameterGenericClass.kt b/idea/testData/quickfix/override/nothingToOverride/beforeAddParameterGenericClass.kt new file mode 100644 index 00000000000..4fae2df2a06 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeAddParameterGenericClass.kt @@ -0,0 +1,8 @@ +// "Change function signature to 'override fun f(a: Int, x: T)'" "true" +trait A { + fun f(a: Int, b: R) +} + +class B : A { + override fun f(x: T) {} +} diff --git a/idea/testData/quickfix/override/nothingToOverride/beforeSwapParametersGenericClass.kt b/idea/testData/quickfix/override/nothingToOverride/beforeSwapParametersGenericClass.kt new file mode 100644 index 00000000000..b8dac5dbef7 --- /dev/null +++ b/idea/testData/quickfix/override/nothingToOverride/beforeSwapParametersGenericClass.kt @@ -0,0 +1,8 @@ +// "Change function signature to 'override fun f(y: S, x: List>)'" "true" +trait A { + fun f(a: Q, b: List>) +} + +class B : A { + override fun f(x: List>, y: S) {} +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index d5fc32546e1..350eaa4bd87 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -906,6 +906,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddParameter.kt"); } + @TestMetadata("beforeAddParameterGenericClass.kt") + public void testAddParameterGenericClass() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddParameterGenericClass.kt"); + } + @TestMetadata("beforeAddParameterMultiple.kt") public void testAddParameterMultiple() throws Exception { doTest("idea/testData/quickfix/override/nothingToOverride/beforeAddParameterMultiple.kt"); @@ -1000,6 +1005,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/nothingToOverride/beforeRemoveParameterTwoTraits.kt"); } + @TestMetadata("beforeSwapParametersGenericClass.kt") + public void testSwapParametersGenericClass() throws Exception { + doTest("idea/testData/quickfix/override/nothingToOverride/beforeSwapParametersGenericClass.kt"); + } + } @TestMetadata("idea/testData/quickfix/override/typeMismatchOnOverride") From 2ad1bfa7438ef9c81e3d80192928459bcc3cc984 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Wed, 22 May 2013 19:23:59 +0400 Subject: [PATCH 38/92] KT-3161 JetCommenter implementation stub --- .../jetbrains/jet/plugin/JetCommenter.java | 42 +++++++++++++- .../editor/commenter/generateDocComment.kt | 2 + .../commenter/generateDocComment_after.kt | 4 ++ .../editor/commenter/newLineInComment.kt | 4 ++ .../commenter/newLineInComment_after.kt | 5 ++ .../jet/editor/JetCommenterTest.java | 58 +++++++++++++++++++ 6 files changed, 113 insertions(+), 2 deletions(-) create mode 100644 idea/testData/editor/commenter/generateDocComment.kt create mode 100644 idea/testData/editor/commenter/generateDocComment_after.kt create mode 100644 idea/testData/editor/commenter/newLineInComment.kt create mode 100644 idea/testData/editor/commenter/newLineInComment_after.kt create mode 100644 idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java diff --git a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java index b7c260dfa93..2e3d3ba5e1f 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java +++ b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java @@ -16,9 +16,12 @@ package org.jetbrains.jet.plugin; -import com.intellij.lang.Commenter; +import com.intellij.lang.CodeDocumentationAwareCommenter; +import com.intellij.psi.PsiComment; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.jet.lexer.JetTokens; -public class JetCommenter implements Commenter { +public class JetCommenter implements CodeDocumentationAwareCommenter { @Override public String getLineCommentPrefix() { return "//"; @@ -43,4 +46,39 @@ public class JetCommenter implements Commenter { public String getCommentedBlockCommentSuffix() { return null; } + + @Override + public IElementType getLineCommentTokenType() { + return JetTokens.EOL_COMMENT; + } + + @Override + public IElementType getBlockCommentTokenType() { + return JetTokens.BLOCK_COMMENT; + } + + @Override + public IElementType getDocumentationCommentTokenType() { + return JetTokens.DOC_COMMENT; + } + + @Override + public String getDocumentationCommentPrefix() { + return "/**"; + } + + @Override + public String getDocumentationCommentLinePrefix() { + return "*"; + } + + @Override + public String getDocumentationCommentSuffix() { + return "*/"; + } + + @Override + public boolean isDocumentationComment(PsiComment element) { + return element.getTokenType().equals(JetTokens.DOC_COMMENT); + } } diff --git a/idea/testData/editor/commenter/generateDocComment.kt b/idea/testData/editor/commenter/generateDocComment.kt new file mode 100644 index 00000000000..7e76a37c71b --- /dev/null +++ b/idea/testData/editor/commenter/generateDocComment.kt @@ -0,0 +1,2 @@ +/** +fun test() = 0 \ No newline at end of file diff --git a/idea/testData/editor/commenter/generateDocComment_after.kt b/idea/testData/editor/commenter/generateDocComment_after.kt new file mode 100644 index 00000000000..f60322d8e68 --- /dev/null +++ b/idea/testData/editor/commenter/generateDocComment_after.kt @@ -0,0 +1,4 @@ +/** + * + */ +fun test() = 0 \ No newline at end of file diff --git a/idea/testData/editor/commenter/newLineInComment.kt b/idea/testData/editor/commenter/newLineInComment.kt new file mode 100644 index 00000000000..5f9507de398 --- /dev/null +++ b/idea/testData/editor/commenter/newLineInComment.kt @@ -0,0 +1,4 @@ +/** + * x + */ +fun test() = 0 \ No newline at end of file diff --git a/idea/testData/editor/commenter/newLineInComment_after.kt b/idea/testData/editor/commenter/newLineInComment_after.kt new file mode 100644 index 00000000000..130bcc93cb1 --- /dev/null +++ b/idea/testData/editor/commenter/newLineInComment_after.kt @@ -0,0 +1,5 @@ +/** + * x + * + */ +fun test() = 0 \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java b/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java new file mode 100644 index 00000000000..967ef967b7d --- /dev/null +++ b/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java @@ -0,0 +1,58 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.editor; + +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.testFramework.EditorTestUtil; +import com.intellij.testFramework.LightCodeInsightTestCase; +import org.jetbrains.jet.plugin.PluginTestCaseBase; + +import java.io.File; + +public class JetCommenterTest extends LightCodeInsightTestCase { + private static final String BASE_PATH = + new File(PluginTestCaseBase.getTestDataPathBase(), "/editor/commenter/").getAbsolutePath(); + + public void testGenerateDocComment() throws Exception { + doNewLineTypingTest(); + } + + public void testNewLineInComment() throws Exception { + doNewLineTypingTest(); + } + + private void doNewLineTypingTest() throws Exception { + configure(); + EditorTestUtil.performTypingAction(getEditor(), '\n'); + check(); + } + + private void configure() throws Exception { + configureFromFileText("a.kt", loadFile(getTestName(false) + ".kt")); + } + + private void check() throws Exception { + checkResultByText(loadFile(getTestName(false) + "_after.kt")); + } + + protected static String loadFile(String name) throws Exception { + String text = FileUtil.loadFile(new File(BASE_PATH, name)); + text = StringUtil.convertLineSeparators(text); + return text; + } +} From 5ff1f746d4eda34fa8c0e2be72f7e546da07f215 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Thu, 23 May 2013 18:32:13 +0400 Subject: [PATCH 39/92] KT-1545, KT-3161 KDoc lexer & parser --- compiler/frontend/buildLexer.xml | 4 +- .../org/jetbrains/jet/kdoc/lexer/KDoc.flex | 75 +++ .../jetbrains/jet/kdoc/lexer/KDocLexer.java | 27 + .../jetbrains/jet/kdoc/lexer/KDocToken.java | 27 + .../jetbrains/jet/kdoc/lexer/KDocTokens.java | 56 ++ .../jetbrains/jet/kdoc/lexer/_KDocLexer.java | 539 ++++++++++++++++++ .../jetbrains/jet/kdoc/parser/KDocParser.java | 39 ++ .../org/jetbrains/jet/kdoc/psi/api/KDoc.java | 23 + .../jet/kdoc/psi/api/KDocElement.java | 22 + .../jet/kdoc/psi/impl/KDocElementImpl.java | 40 ++ .../jetbrains/jet/kdoc/psi/impl/KDocImpl.java | 48 ++ .../jetbrains/jet/lang/psi/JetVisitor.java | 1 - .../org/jetbrains/jet/lexer/JetTokens.java | 11 +- .../org/jetbrains/jet/lexer/_JetLexer.java | 253 ++++---- .../psi/DocCommentAtBeginningOfFile2.txt | 4 - .../psi/DocCommentAtBeginningOfFile3.txt | 4 - .../psi/DocCommentAtBeginningOfFile4.txt | 4 - compiler/testData/psi/EOLsInComments.txt | 10 +- compiler/testData/psi/NestedComments.txt | 19 +- .../psi/examples/array/MutableArray.txt | 41 +- .../DocCommentAtBeginningOfFile1.jet | 0 .../DocCommentAtBeginningOfFile1.txt | 3 +- .../DocCommentAtBeginningOfFile2.jet | 0 .../psi/kdoc/DocCommentAtBeginningOfFile2.txt | 7 + .../DocCommentAtBeginningOfFile3.jet | 0 .../psi/kdoc/DocCommentAtBeginningOfFile3.txt | 7 + .../DocCommentAtBeginningOfFile4.jet | 0 .../psi/kdoc/DocCommentAtBeginningOfFile4.txt | 9 + .../psi/kdoc/EndOnLeadingAsterisks.kt | 2 + .../psi/kdoc/EndOnLeadingAsterisks.txt | 7 + .../testData/psi/kdoc/EndRightAfterText.kt | 1 + .../testData/psi/kdoc/EndRightAfterText.txt | 7 + compiler/testData/psi/kdoc/Incomplete.kt | 2 + compiler/testData/psi/kdoc/Incomplete.txt | 7 + compiler/testData/psi/kdoc/Simple.kt | 7 + compiler/testData/psi/kdoc/Simple.txt | 52 ++ .../psi/kdoc/TextRightAfterLeadAsterisks.kt | 3 + .../psi/kdoc/TextRightAfterLeadAsterisks.txt | 10 + .../jetbrains/jet/parsing/JetParsingTest.java | 1 + .../jetbrains/jet/plugin/JetCommenter.java | 3 +- 40 files changed, 1221 insertions(+), 154 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java delete mode 100644 compiler/testData/psi/DocCommentAtBeginningOfFile2.txt delete mode 100644 compiler/testData/psi/DocCommentAtBeginningOfFile3.txt delete mode 100644 compiler/testData/psi/DocCommentAtBeginningOfFile4.txt rename compiler/testData/psi/{ => kdoc}/DocCommentAtBeginningOfFile1.jet (100%) rename compiler/testData/psi/{ => kdoc}/DocCommentAtBeginningOfFile1.txt (65%) rename compiler/testData/psi/{ => kdoc}/DocCommentAtBeginningOfFile2.jet (100%) create mode 100644 compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt rename compiler/testData/psi/{ => kdoc}/DocCommentAtBeginningOfFile3.jet (100%) create mode 100644 compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt rename compiler/testData/psi/{ => kdoc}/DocCommentAtBeginningOfFile4.jet (100%) create mode 100644 compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt create mode 100644 compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt create mode 100644 compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt create mode 100644 compiler/testData/psi/kdoc/EndRightAfterText.kt create mode 100644 compiler/testData/psi/kdoc/EndRightAfterText.txt create mode 100644 compiler/testData/psi/kdoc/Incomplete.kt create mode 100644 compiler/testData/psi/kdoc/Incomplete.txt create mode 100644 compiler/testData/psi/kdoc/Simple.kt create mode 100644 compiler/testData/psi/kdoc/Simple.txt create mode 100644 compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt create mode 100644 compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt diff --git a/compiler/frontend/buildLexer.xml b/compiler/frontend/buildLexer.xml index f39f99d46cd..b7539670c0d 100644 --- a/compiler/frontend/buildLexer.xml +++ b/compiler/frontend/buildLexer.xml @@ -46,6 +46,8 @@ + destdir="${home}/src/org/jetbrains/jet/lexer/"/> + diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex new file mode 100644 index 00000000000..ff96ccf0bec --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex @@ -0,0 +1,75 @@ +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; +import com.intellij.psi.tree.IElementType; +import com.intellij.util.text.CharArrayUtil; + +%% + +%unicode +%class _KDocLexer +%implements FlexLexer + +%{ + public _KDocLexer() { + this((java.io.Reader)null); + } + + private final boolean isLastToken() { + return zzMarkedPos == zzBuffer.length(); + } + + private final Boolean yytextContainLineBreaks() { + return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); + } + + private final void pushbackEnd() { + if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { + yypushback(2); + } + } + + private final void pushbackText() { + int i = zzStartRead; + while (zzBuffer.charAt(i) == '*') i++; + yypushback(zzMarkedPos - i); + } +%} + +%function advance +%type IElementType +%eof{ + return; +%eof} + +%state CONTENTS +%state LINE_BEGINNING + +WHITE_SPACE_CHAR =[\ \t\f\n\r] +NOT_WHITE_SPACE_CHAR=[^\ \t\f\n\r] + +%% + + + "/**" { yybegin(CONTENTS); + return KDocTokens.START; } +"*"+ "/" { if (isLastToken()) + return KDocTokens.END; } + +// hack: make longest match + "*"+ {NOT_WHITE_SPACE_CHAR}* { pushbackText(); + yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; } + + { + // todo: put markdown and @tags token patterns here + + {NOT_WHITE_SPACE_CHAR}+ { pushbackEnd(); + return KDocTokens.TEXT; } + {WHITE_SPACE_CHAR}+ { if (yytextContainLineBreaks()) + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; } +} + +. { return TokenType.BAD_CHARACTER; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java new file mode 100644 index 00000000000..dd9be21a218 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexAdapter; + +import java.io.Reader; + +public class KDocLexer extends FlexAdapter { + public KDocLexer() { + super(new _KDocLexer((Reader) null)); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java new file mode 100644 index 00000000000..3d321b008f7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocToken.java @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lexer.JetToken; + +public class KDocToken extends JetToken { + public KDocToken(@NotNull @NonNls String debugName) { + super(debugName); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java new file mode 100644 index 00000000000..217eb51c14d --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lang.ASTNode; +import com.intellij.lang.PsiBuilder; +import com.intellij.lang.PsiBuilderFactory; +import com.intellij.lang.PsiParser; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.tree.ILazyParseableElementType; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.kdoc.parser.KDocParser; +import org.jetbrains.jet.kdoc.psi.impl.KDocImpl; +import org.jetbrains.jet.plugin.JetLanguage; + +public interface KDocTokens { + ILazyParseableElementType KDOC = new ILazyParseableElementType("KDoc", JetLanguage.INSTANCE) { + @Override + public ASTNode parseContents(ASTNode chameleon) { + PsiElement parentElement = chameleon.getTreeParent().getPsi(); + Project project = parentElement.getProject(); + PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder(project, chameleon, new KDocLexer(), getLanguage(), + chameleon.getText()); + PsiParser parser = new KDocParser(); + + return parser.parse(this, builder).getFirstChildNode(); + } + + @Nullable + @Override + public ASTNode createNode(CharSequence text) { + return new KDocImpl(text); + } + }; + + KDocToken START = new KDocToken("KDOC_START"); + KDocToken END = new KDocToken("KDOC_END"); + KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); + + KDocToken TEXT = new KDocToken("KDOC_TEXT"); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java new file mode 100644 index 00000000000..c2007811156 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java @@ -0,0 +1,539 @@ +/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ + +package org.jetbrains.jet.kdoc.lexer; + +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; +import com.intellij.psi.tree.IElementType; +import com.intellij.util.text.CharArrayUtil; + + +/** + * This class is a scanner generated by + * JFlex 1.4.3 + * on 23.05.13 19:26 from the specification file + * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex + */ +class _KDocLexer implements FlexLexer { + /** initial size of the lookahead buffer */ + private static final int ZZ_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int LINE_BEGINNING = 4; + public static final int CONTENTS = 2; + public static final int YYINITIAL = 0; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0, 1, 1, 2, 2 + }; + + /** + * Translates characters to character classes + */ + private static final String ZZ_CMAP_PACKED = + "\11\0\1\1\1\4\1\0\2\1\22\0\1\1\11\0\1\3\4\0"+ + "\1\2\uffd0\0"; + + /** + * Translates characters to character classes + */ + private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED); + + /** + * Translates DFA states to action switch labels. + */ + private static final int [] ZZ_ACTION = zzUnpackAction(); + + private static final String ZZ_ACTION_PACKED_0 = + "\3\0\3\1\1\2\1\3\1\2\1\4\1\0\1\5"+ + "\1\0\1\5\1\4\1\5\1\6"; + + private static int [] zzUnpackAction() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAction(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /** + * Translates a state to a row index in the transition table + */ + private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); + + private static final String ZZ_ROWMAP_PACKED_0 = + "\0\0\0\5\0\12\0\17\0\24\0\31\0\36\0\43"+ + "\0\50\0\55\0\62\0\17\0\31\0\36\0\67\0\67"+ + "\0\17"; + + private static int [] zzUnpackRowMap() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackRowMap(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int high = packed.charAt(i++) << 16; + result[j++] = high | packed.charAt(i++); + } + return j; + } + + /** + * The transition table of the DFA + */ + private static final int [] ZZ_TRANS = zzUnpackTrans(); + + private static final String ZZ_TRANS_PACKED_0 = + "\2\4\1\5\1\6\1\0\1\7\1\10\1\7\1\11"+ + "\1\10\1\7\1\10\1\7\1\12\1\10\10\0\1\13"+ + "\3\0\1\14\1\15\1\0\1\7\1\0\2\7\2\0"+ + "\1\10\2\0\1\10\1\7\1\0\1\16\1\11\1\0"+ + "\1\17\1\0\1\20\1\12\4\0\1\21\1\0\1\17"+ + "\1\0\2\17\1\0"; + + private static int [] zzUnpackTrans() { + int [] result = new int[60]; + int offset = 0; + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackTrans(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /* error codes */ + private static final int ZZ_UNKNOWN_ERROR = 0; + private static final int ZZ_NO_MATCH = 1; + private static final int ZZ_PUSHBACK_2BIG = 2; + private static final char[] EMPTY_BUFFER = new char[0]; + private static final int YYEOF = -1; + private static java.io.Reader zzReader = null; // Fake + + /* error messages for the codes above */ + private static final String ZZ_ERROR_MSG[] = { + "Unkown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); + + private static final String ZZ_ATTRIBUTE_PACKED_0 = + "\3\0\1\11\6\1\1\0\1\11\1\0\3\1\1\11"; + + private static int [] zzUnpackAttribute() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAttribute(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + /** the current state of the DFA */ + private int zzState; + + /** the current lexical state */ + private int zzLexicalState = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private CharSequence zzBuffer = ""; + + /** this buffer may contains the current text array to be matched when it is cheap to acquire it */ + private char[] zzBufferArray; + + /** the textposition at the last accepting state */ + private int zzMarkedPos; + + /** the textposition at the last state to be included in yytext */ + private int zzPushbackPos; + + /** the current text position in the buffer */ + private int zzCurrentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int zzStartRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int zzEndRead; + + /** + * zzAtBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean zzAtBOL = true; + + /** zzAtEOF == true <=> the scanner is at the EOF */ + private boolean zzAtEOF; + + /** denotes if the user-EOF-code has already been executed */ + private boolean zzEOFDone; + + /* user code: */ + public _KDocLexer() { + this((java.io.Reader)null); + } + + private final boolean isLastToken() { + return zzMarkedPos == zzBuffer.length(); + } + + private final Boolean yytextContainLineBreaks() { + return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); + } + + private final void pushbackEnd() { + if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { + yypushback(2); + } + } + + private final void pushbackText() { + int i = zzStartRead; + while (zzBuffer.charAt(i) == '*') i++; + yypushback(zzMarkedPos - i); + } + + + _KDocLexer(java.io.Reader in) { + this.zzReader = in; + } + + /** + * Creates a new scanner. + * There is also java.io.Reader version of this constructor. + * + * @param in the java.io.Inputstream to read input from. + */ + _KDocLexer(java.io.InputStream in) { + this(new java.io.InputStreamReader(in)); + } + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] zzUnpackCMap(String packed) { + char [] map = new char[0x10000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 24) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + public final int getTokenStart(){ + return zzStartRead; + } + + public final int getTokenEnd(){ + return getTokenStart() + yylength(); + } + + public void reset(CharSequence buffer, int start, int end,int initialState){ + zzBuffer = buffer; + zzBufferArray = com.intellij.util.text.CharArrayUtil.fromSequenceWithoutCopying(buffer); + zzCurrentPos = zzMarkedPos = zzStartRead = start; + zzPushbackPos = 0; + zzAtEOF = false; + zzAtBOL = true; + zzEndRead = end; + yybegin(initialState); + } + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception java.io.IOException if any I/O-Error occurs + */ + private boolean zzRefill() throws java.io.IOException { + return true; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return zzLexicalState; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + zzLexicalState = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final CharSequence yytext() { + return zzBuffer.subSequence(zzStartRead, zzMarkedPos); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return zzBufferArray != null ? zzBufferArray[zzStartRead+pos]:zzBuffer.charAt(zzStartRead+pos); + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return zzMarkedPos-zzStartRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void zzScanError(int errorCode) { + String message; + try { + message = ZZ_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + public void yypushback(int number) { + if ( number > yylength() ) + zzScanError(ZZ_PUSHBACK_2BIG); + + zzMarkedPos -= number; + } + + + /** + * Contains user EOF-code, which will be executed exactly once, + * when the end of file is reached + */ + private void zzDoEOF() { + if (!zzEOFDone) { + zzEOFDone = true; + return; + + } + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception java.io.IOException if any I/O-Error occurs + */ + public IElementType advance() throws java.io.IOException { + int zzInput; + int zzAction; + + // cached fields: + int zzCurrentPosL; + int zzMarkedPosL; + int zzEndReadL = zzEndRead; + CharSequence zzBufferL = zzBuffer; + char[] zzBufferArrayL = zzBufferArray; + char [] zzCMapL = ZZ_CMAP; + + int [] zzTransL = ZZ_TRANS; + int [] zzRowMapL = ZZ_ROWMAP; + int [] zzAttrL = ZZ_ATTRIBUTE; + + while (true) { + zzMarkedPosL = zzMarkedPos; + + zzAction = -1; + + zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; + + zzState = ZZ_LEXSTATE[zzLexicalState]; + + + zzForAction: { + while (true) { + + if (zzCurrentPosL < zzEndReadL) + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + else if (zzAtEOF) { + zzInput = YYEOF; + break zzForAction; + } + else { + // store back cached positions + zzCurrentPos = zzCurrentPosL; + zzMarkedPos = zzMarkedPosL; + boolean eof = zzRefill(); + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + zzEndReadL = zzEndRead; + if (eof) { + zzInput = YYEOF; + break zzForAction; + } + else { + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + } + } + int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; + if (zzNext == -1) break zzForAction; + zzState = zzNext; + + int zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + zzMarkedPosL = zzCurrentPosL; + if ( (zzAttributes & 8) == 8 ) break zzForAction; + } + + } + } + + // store back cached position + zzMarkedPos = zzMarkedPosL; + + switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { + case 6: + { yybegin(CONTENTS); + return KDocTokens.START; + } + case 7: break; + case 5: + { if (isLastToken()) + return KDocTokens.END; + } + case 8: break; + case 1: + { return TokenType.BAD_CHARACTER; + } + case 9: break; + case 2: + { pushbackEnd(); + return KDocTokens.TEXT; + } + case 10: break; + case 4: + { pushbackText(); + yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; + } + case 11: break; + case 3: + { if (yytextContainLineBreaks()) + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; + } + case 12: break; + default: + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true; + zzDoEOF(); + return null; + } + else { + zzScanError(ZZ_NO_MATCH); + } + } + } + } + + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java new file mode 100644 index 00000000000..dd2e07e168c --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/parser/KDocParser.java @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.parser; + +import com.intellij.lang.ASTNode; +import com.intellij.lang.PsiBuilder; +import com.intellij.lang.PsiParser; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; + +public class KDocParser implements PsiParser { + @Override + @NotNull + public ASTNode parse(IElementType root, PsiBuilder builder) { + PsiBuilder.Marker rootMarker = builder.mark(); + + // todo: parse KDoc tags, markdown, etc... + while (!builder.eof()) { + builder.advanceLexer(); + } + + rootMarker.done(root); + return builder.getTreeBuilt(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java new file mode 100644 index 00000000000..5c5c40daef1 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDoc.java @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.api; + +import com.intellij.psi.PsiComment; + +// Don't implement JetElement (or it will be treated as statement) +public interface KDoc extends PsiComment { +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java new file mode 100644 index 00000000000..32119bebdd9 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.api; + +import org.jetbrains.jet.lang.psi.JetElement; + +public interface KDocElement extends JetElement { +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java new file mode 100644 index 00000000000..39716bac4b7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocElementImpl.java @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.impl; + +import com.intellij.extapi.psi.ASTWrapperPsiElement; +import com.intellij.lang.ASTNode; +import com.intellij.lang.Language; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.plugin.JetLanguage; + +public abstract class KDocElementImpl extends ASTWrapperPsiElement { + @NotNull + @Override + public Language getLanguage() { + return JetLanguage.INSTANCE; + } + + @Override + public String toString() { + return getNode().getElementType().toString(); + } + + public KDocElementImpl(@NotNull ASTNode node) { + super(node); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java new file mode 100644 index 00000000000..5cb4db81a40 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/impl/KDocImpl.java @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.kdoc.psi.impl; + +import com.intellij.lang.Language; +import com.intellij.psi.impl.source.tree.LazyParseablePsiElement; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; +import org.jetbrains.jet.kdoc.psi.api.KDoc; +import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.plugin.JetLanguage; + +public class KDocImpl extends LazyParseablePsiElement implements KDoc { + public KDocImpl(CharSequence buffer) { + super(KDocTokens.KDOC, buffer); + } + + @NotNull + @Override + public Language getLanguage() { + return JetLanguage.INSTANCE; + } + + @Override + public String toString() { + return getNode().getElementType().toString(); + } + + @Override + public IElementType getTokenType() { + return JetTokens.DOC_COMMENT; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java index 082ad68d492..7c6058ef924 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetVisitor.java @@ -408,5 +408,4 @@ public class JetVisitor extends PsiElementVisitor { public R visitEscapeStringTemplateEntry(JetEscapeStringTemplateEntry entry, D data) { return visitStringTemplateEntry(entry, data); } - } diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java index 8bd4eb4594d..0c0124566b7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java @@ -19,14 +19,17 @@ package org.jetbrains.jet.lexer; import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; public interface JetTokens { JetToken EOF = new JetToken("EOF"); - JetToken BLOCK_COMMENT = new JetToken("BLOCK_COMMENT"); - JetToken DOC_COMMENT = new JetToken("DOC_COMMENT"); - JetToken EOL_COMMENT = new JetToken("EOL_COMMENT"); - JetToken SHEBANG_COMMENT = new JetToken("SHEBANG_COMMENT"); + JetToken BLOCK_COMMENT = new JetToken("BLOCK_COMMENT"); + JetToken EOL_COMMENT = new JetToken("EOL_COMMENT"); + JetToken SHEBANG_COMMENT = new JetToken("SHEBANG_COMMENT"); + + //JetToken DOC_COMMENT = new JetToken("DOC_COMMENT"); + IElementType DOC_COMMENT = KDocTokens.KDOC; IElementType WHITE_SPACE = TokenType.WHITE_SPACE; diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java index d7cf8fbff21..f56cf18375f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java @@ -1,21 +1,18 @@ -/* The following code was generated by JFlex 1.4.3 on 3/12/13 8:22 PM */ +/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ package org.jetbrains.jet.lexer; -import java.util.*; -import com.intellij.lexer.*; -import com.intellij.psi.*; +import com.intellij.lexer.FlexLexer; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.util.containers.Stack; -import org.jetbrains.jet.lexer.JetTokens; - /** * This class is a scanner generated by * JFlex 1.4.3 - * on 3/12/13 8:22 PM from the specification file - * C:/1/kotlin/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex + * on 23.05.13 19:26 from the specification file + * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex */ class _JetLexer implements FlexLexer { /** initial size of the lookahead buffer */ @@ -843,7 +840,7 @@ class _JetLexer implements FlexLexer { while (true) { if (zzCurrentPosL < zzEndReadL) - zzInput = zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++]:zzBufferL.charAt(zzCurrentPosL++); + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); else if (zzAtEOF) { zzInput = YYEOF; break zzForAction; @@ -863,7 +860,7 @@ class _JetLexer implements FlexLexer { break zzForAction; } else { - zzInput = zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++]:zzBufferL.charAt(zzCurrentPosL++); + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); } } int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; @@ -904,193 +901,202 @@ class _JetLexer implements FlexLexer { { return JetTokens.NULL_KEYWORD ; } case 110: break; + case 35: + { if (lBraceCount == 0) { + popState(); + return JetTokens.LONG_TEMPLATE_ENTRY_END; + } + lBraceCount--; + return JetTokens.RBRACE; + } + case 111: break; case 16: { return JetTokens.LT ; } - case 111: break; + case 112: break; case 54: { return JetTokens.DO_KEYWORD ; } - case 112: break; + case 113: break; case 20: { return JetTokens.PLUS ; } - case 113: break; + case 114: break; case 59: { return JetTokens.PLUSEQ ; } - case 114: break; + case 115: break; case 94: { popState(); return JetTokens.THIS_KEYWORD; } - case 115: break; + case 116: break; case 28: { return JetTokens.COMMA ; } - case 116: break; + case 117: break; case 17: { return JetTokens.GT ; } - case 117: break; + case 118: break; case 4: { return JetTokens.WHITE_SPACE; } - case 118: break; + case 119: break; case 26: { return JetTokens.RPAR ; } - case 119: break; + case 120: break; case 57: { return JetTokens.DOUBLE_ARROW; } - case 120: break; + case 121: break; case 88: { return JetTokens.TRUE_KEYWORD ; } - case 121: break; + case 122: break; case 82: { return JetTokens.IDE_TEMPLATE_START ; } - case 122: break; + case 123: break; case 37: { return JetTokens.FIELD_IDENTIFIER; } - case 123: break; + case 124: break; case 61: { return JetTokens.ANDAND ; } - case 124: break; + case 125: break; case 66: { pushState(LONG_TEMPLATE_ENTRY); return JetTokens.LONG_TEMPLATE_ENTRY_START; } - case 125: break; + case 126: break; case 36: { return JetTokens.FLOAT_LITERAL; } - case 126: break; + case 127: break; case 40: { return JetTokens.EOL_COMMENT; } - case 127: break; + case 128: break; case 92: { return JetTokens.WHEN_KEYWORD ; } - case 128: break; + case 129: break; case 75: { pushState(RAW_STRING); return JetTokens.OPEN_QUOTE; } - case 129: break; + case 130: break; case 22: { return JetTokens.COLON ; } - case 130: break; + case 131: break; case 55: { return JetTokens.LTEQ ; } - case 131: break; + case 132: break; case 47: { return JetTokens.ARROW ; } - case 132: break; + case 133: break; case 32: { popState(); return JetTokens.IDENTIFIER; } - case 133: break; + case 134: break; case 23: { return JetTokens.LBRACKET ; } - case 134: break; + case 135: break; case 70: { yypushback(2); return JetTokens.INTEGER_LITERAL; } - case 135: break; + case 136: break; case 11: { return JetTokens.CHARACTER_LITERAL; } - case 136: break; + case 137: break; case 80: { return JetTokens.VAR_KEYWORD ; } - case 137: break; + case 138: break; case 56: { return JetTokens.GTEQ ; } - case 138: break; + case 139: break; case 2: { return JetTokens.INTEGER_LITERAL; } - case 139: break; + case 140: break; case 14: { return JetTokens.RBRACE ; } - case 140: break; + case 141: break; case 98: { return JetTokens.CLASS_KEYWORD ; } - case 141: break; + case 142: break; case 76: { return JetTokens.TRY_KEYWORD ; } - case 142: break; + case 143: break; case 8: { return JetTokens.EXCL ; } - case 143: break; + case 144: break; case 44: { return JetTokens.EXCLEQ ; } - case 144: break; + case 145: break; case 48: { return JetTokens.MINUSEQ ; } - case 145: break; + case 146: break; case 104: { return JetTokens.PACKAGE_KEYWORD ; } - case 146: break; + case 147: break; case 95: { return JetTokens.THROW_KEYWORD ; } - case 147: break; + case 148: break; case 97: { return JetTokens.SUPER_KEYWORD ; } - case 148: break; + case 149: break; + case 69: + { if (commentDepth > 0) { + commentDepth--; + } + else { + int state = yystate(); + popState(); + zzStartRead = commentStart; + return commentStateToTokenType(state); + } + } + case 150: break; case 100: { return JetTokens.WHILE_KEYWORD ; } - case 149: break; + case 151: break; case 46: { return JetTokens.MINUSMINUS; } - case 150: break; + case 152: break; case 105: { return JetTokens.CONTINUE_KEYWORD ; } - case 151: break; + case 153: break; case 73: { return JetTokens.NOT_IN; } - case 152: break; + case 154: break; case 39: { return JetTokens.ATAT ; } - case 153: break; - case 71: - { pushState(DOC_COMMENT); - commentDepth = 0; - commentStart = getTokenStart(); - } - case 154: break; + case 155: break; case 6: { return JetTokens.DIV ; } - case 155: break; - case 65: - { pushState(SHORT_TEMPLATE_ENTRY); - yypushback(yylength() - 1); - return JetTokens.SHORT_TEMPLATE_ENTRY_START; - } case 156: break; case 83: { return JetTokens.IDE_TEMPLATE_END ; @@ -1108,14 +1114,10 @@ class _JetLexer implements FlexLexer { { return JetTokens.QUEST ; } case 160: break; - case 43: - { if (zzCurrentPos == 0) { - return JetTokens.SHEBANG_COMMENT; - } - else { - yypushback(yylength() - 1); - return JetTokens.HASH; - } + case 71: + { pushState(DOC_COMMENT); + commentDepth = 0; + commentStart = getTokenStart(); } case 161: break; case 62: @@ -1142,83 +1144,77 @@ class _JetLexer implements FlexLexer { { return TokenType.BAD_CHARACTER; } case 167: break; + case 65: + { pushState(SHORT_TEMPLATE_ENTRY); + yypushback(yylength() - 1); + return JetTokens.SHORT_TEMPLATE_ENTRY_START; + } + case 168: break; case 72: { return JetTokens.NOT_IS; } - case 168: break; + case 169: break; case 15: { return JetTokens.MUL ; } - case 169: break; + case 170: break; case 24: { return JetTokens.RBRACKET ; } - case 170: break; + case 171: break; case 60: { return JetTokens.PLUSPLUS ; } - case 171: break; - case 87: - { return JetTokens.THIS_KEYWORD ; - } case 172: break; - case 9: - { return JetTokens.DOT ; - } - case 173: break; - case 27: - { return JetTokens.SEMICOLON ; - } - case 174: break; - case 51: - { return JetTokens.IF_KEYWORD ; - } - case 175: break; - case 67: - { return JetTokens.ESCAPE_SEQUENCE; - } - case 176: break; case 41: { pushState(BLOCK_COMMENT); commentDepth = 0; commentStart = getTokenStart(); } + case 173: break; + case 87: + { return JetTokens.THIS_KEYWORD ; + } + case 174: break; + case 9: + { return JetTokens.DOT ; + } + case 175: break; + case 27: + { return JetTokens.SEMICOLON ; + } + case 176: break; + case 51: + { return JetTokens.IF_KEYWORD ; + } case 177: break; + case 67: + { return JetTokens.ESCAPE_SEQUENCE; + } + case 178: break; case 31: { popState(); return JetTokens.CLOSING_QUOTE; } - case 178: break; + case 179: break; case 18: { return JetTokens.EQ ; } - case 179: break; + case 180: break; case 5: { return JetTokens.AT ; } - case 180: break; + case 181: break; case 77: { return JetTokens.AS_SAFE; } - case 181: break; + case 182: break; case 25: { return JetTokens.LPAR ; } - case 182: break; + case 183: break; case 10: { return JetTokens.MINUS ; } - case 183: break; - case 69: - { if (commentDepth > 0) { - commentDepth--; - } - else { - int state = yystate(); - popState(); - zzStartRead = commentStart; - return commentStateToTokenType(state); - } - } case 184: break; case 101: { return JetTokens.FALSE_KEYWORD ; @@ -1288,42 +1284,43 @@ class _JetLexer implements FlexLexer { { return JetTokens.MULTEQ ; } case 201: break; + case 43: + { if (zzCurrentPos == 0) { + return JetTokens.SHEBANG_COMMENT; + } + else { + yypushback(yylength() - 1); + return JetTokens.HASH; + } + } + case 202: break; case 13: { return JetTokens.LBRACE ; } - case 202: break; + case 203: break; case 102: { return JetTokens.OBJECT_KEYWORD ; } - case 203: break; + case 204: break; case 99: { return JetTokens.BREAK_KEYWORD ; } - case 204: break; + case 205: break; case 85: { return JetTokens.BLOCK_COMMENT; } - case 205: break; + case 206: break; case 96: { return JetTokens.TRAIT_KEYWORD ; } - case 206: break; + case 207: break; case 64: { return JetTokens.COLONCOLON; } - case 207: break; + case 208: break; case 33: { } - case 208: break; - case 35: - { if (lBraceCount == 0) { - popState(); - return JetTokens.LONG_TEMPLATE_ENTRY_END; - } - lBraceCount--; - return JetTokens.RBRACE; - } case 209: break; case 7: { return JetTokens.HASH ; diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt deleted file mode 100644 index b6686bdc4a1..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile2.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile2.jet - PsiComment(DOC_COMMENT)('/**\n/**') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt deleted file mode 100644 index 9e62678cdd3..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile3.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile3.jet - PsiComment(DOC_COMMENT)('/**\n\nfooo') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt b/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt deleted file mode 100644 index 3c3a4906909..00000000000 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile4.txt +++ /dev/null @@ -1,4 +0,0 @@ -JetFile: DocCommentAtBeginningOfFile4.jet - PsiComment(DOC_COMMENT)('/**\n\n/**foo*/\n\nasdfas') - NAMESPACE_HEADER - \ No newline at end of file diff --git a/compiler/testData/psi/EOLsInComments.txt b/compiler/testData/psi/EOLsInComments.txt index 6e5482c96d2..22d6429ed4a 100644 --- a/compiler/testData/psi/EOLsInComments.txt +++ b/compiler/testData/psi/EOLsInComments.txt @@ -25,7 +25,10 @@ JetFile: EOLsInComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiWhiteSpace('\n ') - PsiComment(DOC_COMMENT)('/** */') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_END)('*/') PREFIX_EXPRESSION OPERATION_REFERENCE PsiElement(PLUS)('+') @@ -72,7 +75,10 @@ JetFile: EOLsInComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiWhiteSpace(' ') - PsiComment(DOC_COMMENT)('/**\n */') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') PsiWhiteSpace(' ') OPERATION_REFERENCE PsiElement(PLUS)('+') diff --git a/compiler/testData/psi/NestedComments.txt b/compiler/testData/psi/NestedComments.txt index 59e29c154d8..69704f67b61 100644 --- a/compiler/testData/psi/NestedComments.txt +++ b/compiler/testData/psi/NestedComments.txt @@ -32,17 +32,30 @@ JetFile: NestedComments.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/***/') + KDoc + PsiElement(KDOC_START)('/**') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/** /***/*/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/***/') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiWhiteSpace('\n') - PsiComment(DOC_COMMENT)('/** /**\n\n*/***/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)('/**') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') diff --git a/compiler/testData/psi/examples/array/MutableArray.txt b/compiler/testData/psi/examples/array/MutableArray.txt index 9d26293ba66..5f3a7339998 100644 --- a/compiler/testData/psi/examples/array/MutableArray.txt +++ b/compiler/testData/psi/examples/array/MutableArray.txt @@ -1,5 +1,44 @@ JetFile: MutableArray.jet - PsiComment(DOC_COMMENT)('/**\n These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them\n*/') + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('These') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('declarations') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('are') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('"shallow"') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('in') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('the') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('sense') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('that') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('they') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('are') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('not') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('really') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('compiled,') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('only') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('the') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('type-checker') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('uses') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('them') + PsiWhiteSpace('\n') + PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n\n') NAMESPACE_HEADER diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile1.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile1.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.jet diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile1.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt similarity index 65% rename from compiler/testData/psi/DocCommentAtBeginningOfFile1.txt rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt index b0c76e51b08..92ddc1091be 100644 --- a/compiler/testData/psi/DocCommentAtBeginningOfFile1.txt +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile1.txt @@ -1,4 +1,5 @@ JetFile: DocCommentAtBeginningOfFile1.jet - PsiComment(DOC_COMMENT)('/**') + KDoc + PsiElement(KDOC_START)('/**') NAMESPACE_HEADER \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile2.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile2.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt new file mode 100644 index 00000000000..671a1aee945 --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile2.txt @@ -0,0 +1,7 @@ +JetFile: DocCommentAtBeginningOfFile2.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_TEXT)('/**') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile3.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile3.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt new file mode 100644 index 00000000000..b52d14d6751 --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile3.txt @@ -0,0 +1,7 @@ +JetFile: DocCommentAtBeginningOfFile3.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('fooo') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/DocCommentAtBeginningOfFile4.jet b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.jet similarity index 100% rename from compiler/testData/psi/DocCommentAtBeginningOfFile4.jet rename to compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.jet diff --git a/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt new file mode 100644 index 00000000000..448c37b71ec --- /dev/null +++ b/compiler/testData/psi/kdoc/DocCommentAtBeginningOfFile4.txt @@ -0,0 +1,9 @@ +JetFile: DocCommentAtBeginningOfFile4.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('/**foo*/') + PsiWhiteSpace('\n\n') + PsiElement(KDOC_TEXT)('asdfas') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt new file mode 100644 index 00000000000..a33dbe069c4 --- /dev/null +++ b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.kt @@ -0,0 +1,2 @@ +/** + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt new file mode 100644 index 00000000000..ae11f8e6eaf --- /dev/null +++ b/compiler/testData/psi/kdoc/EndOnLeadingAsterisks.txt @@ -0,0 +1,7 @@ +JetFile: EndOnLeadingAsterisks.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndRightAfterText.kt b/compiler/testData/psi/kdoc/EndRightAfterText.kt new file mode 100644 index 00000000000..ccbbe6b06a8 --- /dev/null +++ b/compiler/testData/psi/kdoc/EndRightAfterText.kt @@ -0,0 +1 @@ +/**text*/ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/EndRightAfterText.txt b/compiler/testData/psi/kdoc/EndRightAfterText.txt new file mode 100644 index 00000000000..77d84b91e6c --- /dev/null +++ b/compiler/testData/psi/kdoc/EndRightAfterText.txt @@ -0,0 +1,7 @@ +JetFile: EndRightAfterText.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiElement(KDOC_TEXT)('text') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Incomplete.kt b/compiler/testData/psi/kdoc/Incomplete.kt new file mode 100644 index 00000000000..cd45fbeed1d --- /dev/null +++ b/compiler/testData/psi/kdoc/Incomplete.kt @@ -0,0 +1,2 @@ +/** + contents \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Incomplete.txt b/compiler/testData/psi/kdoc/Incomplete.txt new file mode 100644 index 00000000000..349ed596f2f --- /dev/null +++ b/compiler/testData/psi/kdoc/Incomplete.txt @@ -0,0 +1,7 @@ +JetFile: Incomplete.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('contents') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Simple.kt b/compiler/testData/psi/kdoc/Simple.kt new file mode 100644 index 00000000000..af292d07506 --- /dev/null +++ b/compiler/testData/psi/kdoc/Simple.kt @@ -0,0 +1,7 @@ + /** line 0 + line 1 // + ** line 2 /* + line 3 /** +* line * 4 + *** line */ 5 + ** line 6 */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Simple.txt b/compiler/testData/psi/kdoc/Simple.txt new file mode 100644 index 00000000000..8b705e5e454 --- /dev/null +++ b/compiler/testData/psi/kdoc/Simple.txt @@ -0,0 +1,52 @@ +JetFile: Simple.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('0') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('1') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('//') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('2') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/*') + PsiWhiteSpace('\n ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('3') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('*') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('4') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('***') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' */') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('5') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('line') + PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)('6') + PsiWhiteSpace(' ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt new file mode 100644 index 00000000000..fe101cccbd4 --- /dev/null +++ b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.kt @@ -0,0 +1,3 @@ +/** +**test + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt new file mode 100644 index 00000000000..4123145ff44 --- /dev/null +++ b/compiler/testData/psi/kdoc/TextRightAfterLeadAsterisks.txt @@ -0,0 +1,10 @@ +JetFile: TextRightAfterLeadAsterisks.kt + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n') + PsiElement(KDOC_LEADING_ASTERISK)('**') + PsiElement(KDOC_TEXT)('test') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java index 5ab65c1a2e3..c4e8de90ed4 100644 --- a/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java +++ b/compiler/tests/org/jetbrains/jet/parsing/JetParsingTest.java @@ -139,6 +139,7 @@ public class JetParsingTest extends ParsingTestCase { suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "script", true, factory)); suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "recovery", true, factory)); suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "propertyDelegate", true, factory)); + suite.addTest(JetTestCaseBuilder.suiteForDirectory(prefix, "kdoc", true, factory)); return suite; } diff --git a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java index 2e3d3ba5e1f..c5a11639197 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetCommenter.java +++ b/idea/src/org/jetbrains/jet/plugin/JetCommenter.java @@ -19,6 +19,7 @@ package org.jetbrains.jet.plugin; import com.intellij.lang.CodeDocumentationAwareCommenter; import com.intellij.psi.PsiComment; import com.intellij.psi.tree.IElementType; +import org.jetbrains.jet.kdoc.psi.api.KDoc; import org.jetbrains.jet.lexer.JetTokens; public class JetCommenter implements CodeDocumentationAwareCommenter { @@ -79,6 +80,6 @@ public class JetCommenter implements CodeDocumentationAwareCommenter { @Override public boolean isDocumentationComment(PsiComment element) { - return element.getTokenType().equals(JetTokens.DOC_COMMENT); + return element instanceof KDoc; } } From f9e8683db560a0d01f72891350c63eb3b0464003 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Fri, 24 May 2013 13:42:15 +0400 Subject: [PATCH 40/92] KT-1545, KT-3161 KDoc formatter --- .../jetbrains/jet/plugin/formatter/JetBlock.java | 15 ++++++++++++++- .../formatter/JetFormattingModelBuilder.java | 8 +++++++- .../testData/editor/commenter/newLineInComment.kt | 3 +-- .../editor/commenter/newLineInComment_after.kt | 3 +-- idea/testData/formatter/KDoc.kt | 4 ++++ idea/testData/formatter/KDoc_after.kt | 6 ++++++ .../jetbrains/jet/formatter/JetFormatterTest.java | 4 ++++ 7 files changed, 37 insertions(+), 6 deletions(-) create mode 100644 idea/testData/formatter/KDoc.kt create mode 100644 idea/testData/formatter/KDoc_after.kt diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java index 34f3616a936..cad36209958 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetBlock.java @@ -27,9 +27,13 @@ import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; import org.jetbrains.jet.plugin.JetLanguage; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import static org.jetbrains.jet.JetNodeTypes.*; import static org.jetbrains.jet.lexer.JetTokens.*; @@ -38,6 +42,7 @@ import static org.jetbrains.jet.lexer.JetTokens.*; * @see Block for good JavaDoc documentation */ public class JetBlock extends AbstractBlock { + private static final int KDOC_COMMENT_INDENT = 1; private final ASTAlignmentStrategy myAlignmentStrategy; private final Indent myIndent; private final CodeStyleSettings mySettings; @@ -208,6 +213,9 @@ public class JetBlock extends AbstractBlock { } return new ChildAttributes(Indent.getContinuationIndent(), null); } + else if (type == DOC_COMMENT) { + return new ChildAttributes(Indent.getSpaceIndent(KDOC_COMMENT_INDENT), null); + } if (isIncomplete()) { return super.getChildAttributes(newChildIndex); @@ -321,6 +329,11 @@ public class JetBlock extends AbstractBlock { .in(PROPERTY, FUN) .notForType(BLOCK) .set(Indent.getContinuationWithoutFirstIndent()), + + ASTIndentStrategy.forNode("KDoc comment indent") + .in(DOC_COMMENT) + .forType(KDocTokens.LEADING_ASTERISK, KDocTokens.END) + .set(Indent.getSpaceIndent(KDOC_COMMENT_INDENT)), }; @Nullable diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java index b30cd9184d5..13d4e7e8dc5 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java @@ -25,6 +25,7 @@ import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; import org.jetbrains.jet.plugin.JetLanguage; import static org.jetbrains.jet.JetNodeTypes.*; @@ -34,8 +35,9 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { @NotNull @Override public FormattingModel createModel(PsiElement element, CodeStyleSettings settings) { + PsiFile containingFile = element.getContainingFile().getViewProvider().getPsi(JetLanguage.INSTANCE); JetBlock block = new JetBlock( - element.getNode(), ASTAlignmentStrategy.getNullStrategy(), Indent.getNoneIndent(), null, settings, + containingFile.getNode(), ASTAlignmentStrategy.getNullStrategy(), Indent.getNoneIndent(), null, settings, createSpacingBuilder(settings)); return FormattingModelProvider.createFormattingModelForPsiFile( @@ -53,6 +55,7 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { .between(IMPORT_DIRECTIVE, IMPORT_DIRECTIVE).lineBreakInCode() .after(IMPORT_DIRECTIVE).blankLines(1) + .before(DOC_COMMENT).lineBreakInCode() .before(FUN).lineBreakInCode() .before(PROPERTY).lineBreakInCode() .between(FUN, FUN).blankLines(1) @@ -105,6 +108,9 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { .between(VALUE_ARGUMENT_LIST, FUNCTION_LITERAL_EXPRESSION).spaces(1) .aroundInside(ARROW, WHEN_ENTRY).spaces(1) + + // KDoc + .between(KDocTokens.LEADING_ASTERISK, KDocTokens.TEXT).spacing(1, 100, 0, true, 100) ; } diff --git a/idea/testData/editor/commenter/newLineInComment.kt b/idea/testData/editor/commenter/newLineInComment.kt index 5f9507de398..c933947394e 100644 --- a/idea/testData/editor/commenter/newLineInComment.kt +++ b/idea/testData/editor/commenter/newLineInComment.kt @@ -1,4 +1,3 @@ /** * x - */ -fun test() = 0 \ No newline at end of file + */ \ No newline at end of file diff --git a/idea/testData/editor/commenter/newLineInComment_after.kt b/idea/testData/editor/commenter/newLineInComment_after.kt index 130bcc93cb1..a15a2e7ab9e 100644 --- a/idea/testData/editor/commenter/newLineInComment_after.kt +++ b/idea/testData/editor/commenter/newLineInComment_after.kt @@ -1,5 +1,4 @@ /** * x * - */ -fun test() = 0 \ No newline at end of file + */ \ No newline at end of file diff --git a/idea/testData/formatter/KDoc.kt b/idea/testData/formatter/KDoc.kt new file mode 100644 index 00000000000..a764ec6cf31 --- /dev/null +++ b/idea/testData/formatter/KDoc.kt @@ -0,0 +1,4 @@ +class Test { /** +* do something + */ fun doSomething() = 0 +} \ No newline at end of file diff --git a/idea/testData/formatter/KDoc_after.kt b/idea/testData/formatter/KDoc_after.kt new file mode 100644 index 00000000000..58f3ca3aba3 --- /dev/null +++ b/idea/testData/formatter/KDoc_after.kt @@ -0,0 +1,6 @@ +class Test { + /** + * do something + */ + fun doSomething() = 0 +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java b/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java index 958481189ac..85f31b0e319 100644 --- a/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java +++ b/idea/tests/org/jetbrains/jet/formatter/JetFormatterTest.java @@ -72,6 +72,10 @@ public class JetFormatterTest extends AbstractJetFormatterTest { doTest(); } + public void testKDoc() throws Exception { + doTest(); + } + public void testMultilineFunctionLiteral() throws Exception { doTest(); } From 365f097904ffcf75a6dc434b060aec7f0ae4fd0d Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 12:23:18 +0400 Subject: [PATCH 41/92] Update KetTokens.Comments TokenSet --- .../src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java | 3 +++ compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java | 5 +++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java index 217eb51c14d..96dedc596d7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java @@ -23,6 +23,7 @@ import com.intellij.lang.PsiParser; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.ILazyParseableElementType; +import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.kdoc.parser.KDocParser; import org.jetbrains.jet.kdoc.psi.impl.KDocImpl; @@ -53,4 +54,6 @@ public interface KDocTokens { KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); KDocToken TEXT = new KDocToken("KDOC_TEXT"); + + TokenSet ALL_KDOC_TOKENS = TokenSet.create(START, END, LEADING_ASTERISK, TEXT); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java index 0c0124566b7..4ac4870d047 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java @@ -183,9 +183,10 @@ public interface JetTokens { OPEN_KEYWORD, INNER_KEYWORD, ANNOTATION_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, INLINE_KEYWORD, REIFIED_KEYWORD ); - TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.create(WHITE_SPACE, BLOCK_COMMENT, EOL_COMMENT, DOC_COMMENT, SHEBANG_COMMENT); TokenSet WHITESPACES = TokenSet.create(TokenType.WHITE_SPACE); - TokenSet COMMENTS = TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT); + TokenSet COMMENTS = TokenSet.orSet(TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT), + KDocTokens.ALL_KDOC_TOKENS); + TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.orSet(COMMENTS, TokenSet.create(WHITE_SPACE)); TokenSet STRINGS = TokenSet.create(CHARACTER_LITERAL, REGULAR_STRING_PART); TokenSet OPERATIONS = TokenSet.create(AS_KEYWORD, AS_SAFE, IS_KEYWORD, IN_KEYWORD, DOT, PLUSPLUS, MINUSMINUS, EXCLEXCL, MUL, PLUS, From 12e20378a2adcc56396dac83222887205f3b0f33 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 15:22:52 +0400 Subject: [PATCH 42/92] KDoc lexer refactored (got rid of hacks and separate tokens for words). Fixed bug with isInComment(element) detection. --- .../org/jetbrains/jet/kdoc/lexer/KDoc.flex | 41 +++++------ .../jetbrains/jet/kdoc/lexer/KDocLexer.java | 11 ++- .../jetbrains/jet/kdoc/lexer/KDocTokens.java | 5 +- .../jetbrains/jet/kdoc/lexer/_KDocLexer.java | 69 ++++++++----------- .../jet/kdoc/psi/api/KDocElement.java | 4 +- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 15 ++++ .../org/jetbrains/jet/lexer/JetTokens.java | 10 ++- .../org/jetbrains/jet/lexer/_JetLexer.java | 4 +- compiler/testData/psi/EOLsInComments.txt | 2 +- compiler/testData/psi/NestedComments.txt | 11 ++- .../psi/examples/array/MutableArray.txt | 36 +--------- compiler/testData/psi/kdoc/Simple.txt | 43 ++---------- .../JetKeywordCompletionContributor.java | 3 +- .../formatter/JetFormattingModelBuilder.java | 4 -- 14 files changed, 97 insertions(+), 161 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex index ff96ccf0bec..7a1cbd60f21 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex @@ -23,18 +23,6 @@ import com.intellij.util.text.CharArrayUtil; private final Boolean yytextContainLineBreaks() { return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); } - - private final void pushbackEnd() { - if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { - yypushback(2); - } - } - - private final void pushbackText() { - int i = zzStartRead; - while (zzBuffer.charAt(i) == '*') i++; - yypushback(zzMarkedPos - i); - } %} %function advance @@ -54,22 +42,25 @@ NOT_WHITE_SPACE_CHAR=[^\ \t\f\n\r] "/**" { yybegin(CONTENTS); return KDocTokens.START; } -"*"+ "/" { if (isLastToken()) - return KDocTokens.END; } +"*"+ "/" { if (isLastToken()) return KDocTokens.END; + else return KDocTokens.TEXT; } -// hack: make longest match - "*"+ {NOT_WHITE_SPACE_CHAR}* { pushbackText(); - yybegin(CONTENTS); - return KDocTokens.LEADING_ASTERISK; } + "*"+ { yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; } { - // todo: put markdown and @tags token patterns here + {WHITE_SPACE_CHAR}+ { + if (yytextContainLineBreaks()) { + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; + } else { + yybegin(CONTENTS); + return KDocTokens.TEXT; // internal white space + } + } - {NOT_WHITE_SPACE_CHAR}+ { pushbackEnd(); - return KDocTokens.TEXT; } - {WHITE_SPACE_CHAR}+ { if (yytextContainLineBreaks()) - yybegin(LINE_BEGINNING); - return TokenType.WHITE_SPACE; } + . { yybegin(CONTENTS); + return KDocTokens.TEXT; } } -. { return TokenType.BAD_CHARACTER; } \ No newline at end of file +. { return TokenType.BAD_CHARACTER; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java index dd9be21a218..8f314730f73 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocLexer.java @@ -17,11 +17,18 @@ package org.jetbrains.jet.kdoc.lexer; import com.intellij.lexer.FlexAdapter; +import com.intellij.lexer.MergingLexerAdapter; +import com.intellij.psi.tree.TokenSet; import java.io.Reader; -public class KDocLexer extends FlexAdapter { +public class KDocLexer extends MergingLexerAdapter { public KDocLexer() { - super(new _KDocLexer((Reader) null)); + super( + new FlexAdapter( + new _KDocLexer((Reader) null) + ), + TokenSet.create(KDocTokens.TEXT) + ); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java index 96dedc596d7..92bdb3cbb86 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java @@ -23,7 +23,6 @@ import com.intellij.lang.PsiParser; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.ILazyParseableElementType; -import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.kdoc.parser.KDocParser; import org.jetbrains.jet.kdoc.psi.impl.KDocImpl; @@ -53,7 +52,5 @@ public interface KDocTokens { KDocToken END = new KDocToken("KDOC_END"); KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); - KDocToken TEXT = new KDocToken("KDOC_TEXT"); - - TokenSet ALL_KDOC_TOKENS = TokenSet.create(START, END, LEADING_ASTERISK, TEXT); + KDocToken TEXT = new KDocToken("KDOC_TEXT"); } diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java index c2007811156..c813e40dc93 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ +/* The following code was generated by JFlex 1.4.3 on 25.05.13 15:08 */ package org.jetbrains.jet.kdoc.lexer; @@ -11,7 +11,7 @@ import com.intellij.util.text.CharArrayUtil; /** * This class is a scanner generated by * JFlex 1.4.3 - * on 23.05.13 19:26 from the specification file + * on 25.05.13 15:08 from the specification file * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex */ class _KDocLexer implements FlexLexer { @@ -19,9 +19,11 @@ class _KDocLexer implements FlexLexer { private static final int ZZ_BUFFERSIZE = 16384; /** lexical states */ - public static final int LINE_BEGINNING = 4; + public static final int LINE_BEGINNING = 8; + public static final int STRONG_CONTENTS = 6; public static final int CONTENTS = 2; public static final int YYINITIAL = 0; + public static final int EMPHASIS_CONTENTS = 4; /** * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l @@ -30,7 +32,7 @@ class _KDocLexer implements FlexLexer { * l is of the form l = 2*k, k a non negative integer */ private static final int ZZ_LEXSTATE[] = { - 0, 0, 1, 1, 2, 2 + 0, 0, 1, 1, 1, 1, 1, 1, 2, 2 }; /** @@ -52,10 +54,10 @@ class _KDocLexer implements FlexLexer { private static final String ZZ_ACTION_PACKED_0 = "\3\0\3\1\1\2\1\3\1\2\1\4\1\0\1\5"+ - "\1\0\1\5\1\4\1\5\1\6"; + "\1\0\1\6"; private static int [] zzUnpackAction() { - int [] result = new int[17]; + int [] result = new int[14]; int offset = 0; offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); return result; @@ -80,12 +82,11 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); private static final String ZZ_ROWMAP_PACKED_0 = - "\0\0\0\5\0\12\0\17\0\24\0\31\0\36\0\43"+ - "\0\50\0\55\0\62\0\17\0\31\0\36\0\67\0\67"+ - "\0\17"; + "\0\0\0\5\0\12\0\17\0\24\0\31\0\17\0\36"+ + "\0\31\0\43\0\50\0\17\0\31\0\17"; private static int [] zzUnpackRowMap() { - int [] result = new int[17]; + int [] result = new int[14]; int offset = 0; offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); return result; @@ -110,13 +111,11 @@ class _KDocLexer implements FlexLexer { private static final String ZZ_TRANS_PACKED_0 = "\2\4\1\5\1\6\1\0\1\7\1\10\1\7\1\11"+ "\1\10\1\7\1\10\1\7\1\12\1\10\10\0\1\13"+ - "\3\0\1\14\1\15\1\0\1\7\1\0\2\7\2\0"+ - "\1\10\2\0\1\10\1\7\1\0\1\16\1\11\1\0"+ - "\1\17\1\0\1\20\1\12\4\0\1\21\1\0\1\17"+ - "\1\0\2\17\1\0"; + "\3\0\1\14\1\15\2\0\1\10\2\0\1\10\2\0"+ + "\1\14\1\12\4\0\1\16\1\0"; private static int [] zzUnpackTrans() { - int [] result = new int[60]; + int [] result = new int[45]; int offset = 0; offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); return result; @@ -157,10 +156,11 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); private static final String ZZ_ATTRIBUTE_PACKED_0 = - "\3\0\1\11\6\1\1\0\1\11\1\0\3\1\1\11"; + "\3\0\1\11\2\1\1\11\3\1\1\0\1\11\1\0"+ + "\1\11"; private static int [] zzUnpackAttribute() { - int [] result = new int[17]; + int [] result = new int[14]; int offset = 0; offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); return result; @@ -231,18 +231,6 @@ class _KDocLexer implements FlexLexer { return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); } - private final void pushbackEnd() { - if (isLastToken() && CharArrayUtil.regionMatches(zzBuffer, zzMarkedPos - 2, zzMarkedPos, "*/")) { - yypushback(2); - } - } - - private final void pushbackText() { - int i = zzStartRead; - while (zzBuffer.charAt(i) == '*') i++; - yypushback(zzMarkedPos - i); - } - _KDocLexer(java.io.Reader in) { this.zzReader = in; @@ -497,8 +485,8 @@ class _KDocLexer implements FlexLexer { } case 7: break; case 5: - { if (isLastToken()) - return KDocTokens.END; + { if (isLastToken()) return KDocTokens.END; + else return KDocTokens.TEXT; } case 8: break; case 1: @@ -506,20 +494,23 @@ class _KDocLexer implements FlexLexer { } case 9: break; case 2: - { pushbackEnd(); - return KDocTokens.TEXT; + { yybegin(CONTENTS); + return KDocTokens.TEXT; } case 10: break; case 4: - { pushbackText(); - yybegin(CONTENTS); - return KDocTokens.LEADING_ASTERISK; + { yybegin(CONTENTS); + return KDocTokens.LEADING_ASTERISK; } case 11: break; case 3: - { if (yytextContainLineBreaks()) - yybegin(LINE_BEGINNING); - return TokenType.WHITE_SPACE; + { if (yytextContainLineBreaks()) { + yybegin(LINE_BEGINNING); + return TokenType.WHITE_SPACE; + } else { + yybegin(CONTENTS); + return KDocTokens.TEXT; // internal white space + } } case 12: break; default: diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java index 32119bebdd9..47c368e5cf5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/psi/api/KDocElement.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.kdoc.psi.api; -import org.jetbrains.jet.lang.psi.JetElement; +import com.intellij.psi.PsiElement; -public interface KDocElement extends JetElement { +public interface KDocElement extends PsiElement { } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 0d02f57ad50..bb3a578a368 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -28,10 +28,12 @@ import com.intellij.psi.impl.CheckUtil; import com.intellij.psi.impl.source.codeStyle.CodeEditUtil; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.codeInsight.CommentUtilCore; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetNodeTypes; +import org.jetbrains.jet.kdoc.psi.api.KDocElement; import org.jetbrains.jet.lang.parsing.JetExpressionParsing; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -740,4 +742,17 @@ public class JetPsiUtil { public static String getText(@Nullable PsiElement element) { return element != null ? element.getText() : ""; } + + /** + * CommentUtilCore.isComment fails if element inside comment. + * + * Also, we can not add KDocTokens to COMMENTS TokenSet, because it is used in JetParserDefinition.getCommentTokens(), + * and therefor all COMMENTS tokens will be ignored by PsiBuilder. + * + * @param element + * @return + */ + public static boolean isInComment(PsiElement element) { + return CommentUtilCore.isComment(element) || element instanceof KDocElement; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java index 4ac4870d047..6407280a4a1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/JetTokens.java @@ -184,8 +184,14 @@ public interface JetTokens { PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, INLINE_KEYWORD, REIFIED_KEYWORD ); TokenSet WHITESPACES = TokenSet.create(TokenType.WHITE_SPACE); - TokenSet COMMENTS = TokenSet.orSet(TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT), - KDocTokens.ALL_KDOC_TOKENS); + + /** + * Don't add KDocTokens to COMMENTS TokenSet, because it is used in JetParserDefinition.getCommentTokens(), + * and therefor all COMMENTS tokens will be ignored by PsiBuilder. + * + * @see org.jetbrains.jet.lang.psi.JetPsiUtil.isInComment() + */ + TokenSet COMMENTS = TokenSet.create(EOL_COMMENT, BLOCK_COMMENT, DOC_COMMENT, SHEBANG_COMMENT); TokenSet WHITE_SPACE_OR_COMMENT_BIT_SET = TokenSet.orSet(COMMENTS, TokenSet.create(WHITE_SPACE)); TokenSet STRINGS = TokenSet.create(CHARACTER_LITERAL, REGULAR_STRING_PART); diff --git a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java index f56cf18375f..3cdd6255b6e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lexer/_JetLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 23.05.13 19:26 */ +/* The following code was generated by JFlex 1.4.3 on 25.05.13 15:08 */ package org.jetbrains.jet.lexer; @@ -11,7 +11,7 @@ import com.intellij.util.containers.Stack; /** * This class is a scanner generated by * JFlex 1.4.3 - * on 23.05.13 19:26 from the specification file + * on 25.05.13 15:08 from the specification file * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex */ class _JetLexer implements FlexLexer { diff --git a/compiler/testData/psi/EOLsInComments.txt b/compiler/testData/psi/EOLsInComments.txt index 22d6429ed4a..5102fdb525f 100644 --- a/compiler/testData/psi/EOLsInComments.txt +++ b/compiler/testData/psi/EOLsInComments.txt @@ -27,7 +27,7 @@ JetFile: EOLsInComments.jet PsiWhiteSpace('\n ') KDoc PsiElement(KDOC_START)('/**') - PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)(' ') PsiElement(KDOC_END)('*/') PREFIX_EXPRESSION OPERATION_REFERENCE diff --git a/compiler/testData/psi/NestedComments.txt b/compiler/testData/psi/NestedComments.txt index 69704f67b61..029c4c6d5dd 100644 --- a/compiler/testData/psi/NestedComments.txt +++ b/compiler/testData/psi/NestedComments.txt @@ -41,8 +41,7 @@ JetFile: NestedComments.jet PsiWhiteSpace('\n') KDoc PsiElement(KDOC_START)('/**') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('/***/') + PsiElement(KDOC_TEXT)(' /***/') PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION @@ -50,12 +49,10 @@ JetFile: NestedComments.jet PsiWhiteSpace('\n') KDoc PsiElement(KDOC_START)('/**') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('/**') + PsiElement(KDOC_TEXT)(' /**') PsiWhiteSpace('\n\n') - PsiElement(KDOC_LEADING_ASTERISK)('*') - PsiElement(KDOC_TEXT)('/**') - PsiElement(KDOC_END)('*/') + PsiElement(KDOC_TEXT)('*/') + PsiElement(KDOC_END)('***/') PsiWhiteSpace('\n') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') diff --git a/compiler/testData/psi/examples/array/MutableArray.txt b/compiler/testData/psi/examples/array/MutableArray.txt index 5f3a7339998..c08fd2add36 100644 --- a/compiler/testData/psi/examples/array/MutableArray.txt +++ b/compiler/testData/psi/examples/array/MutableArray.txt @@ -2,41 +2,7 @@ JetFile: MutableArray.jet KDoc PsiElement(KDOC_START)('/**') PsiWhiteSpace('\n ') - PsiElement(KDOC_TEXT)('These') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('declarations') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('are') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('"shallow"') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('in') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('the') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('sense') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('that') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('they') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('are') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('not') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('really') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('compiled,') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('only') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('the') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('type-checker') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('uses') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('them') + PsiElement(KDOC_TEXT)('These declarations are "shallow" in the sense that they are not really compiled, only the type-checker uses them') PsiWhiteSpace('\n') PsiElement(KDOC_END)('*/') PsiWhiteSpace('\n\n') diff --git a/compiler/testData/psi/kdoc/Simple.txt b/compiler/testData/psi/kdoc/Simple.txt index 8b705e5e454..cba272a3bd0 100644 --- a/compiler/testData/psi/kdoc/Simple.txt +++ b/compiler/testData/psi/kdoc/Simple.txt @@ -1,52 +1,23 @@ JetFile: Simple.kt KDoc PsiElement(KDOC_START)('/**') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('0') + PsiElement(KDOC_TEXT)(' line 0') PsiWhiteSpace('\n ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('1') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('//') + PsiElement(KDOC_TEXT)('line 1 //') PsiWhiteSpace('\n ') PsiElement(KDOC_LEADING_ASTERISK)('**') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('2') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('/*') + PsiElement(KDOC_TEXT)(' line 2 /*') PsiWhiteSpace('\n ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('3') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('/**') + PsiElement(KDOC_TEXT)('line 3 /**') PsiWhiteSpace('\n') PsiElement(KDOC_LEADING_ASTERISK)('*') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('*') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('4') + PsiElement(KDOC_TEXT)(' line * 4') PsiWhiteSpace('\n ') PsiElement(KDOC_LEADING_ASTERISK)('***') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' */') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('5') + PsiElement(KDOC_TEXT)(' line */ 5') PsiWhiteSpace('\n ') PsiElement(KDOC_LEADING_ASTERISK)('**') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('line') - PsiWhiteSpace(' ') - PsiElement(KDOC_TEXT)('6') - PsiWhiteSpace(' ') + PsiElement(KDOC_TEXT)(' line 6 ') PsiElement(KDOC_END)('*/') NAMESPACE_HEADER \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetKeywordCompletionContributor.java b/idea/src/org/jetbrains/jet/plugin/completion/JetKeywordCompletionContributor.java index 30e79e51300..5cc6cf04248 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/JetKeywordCompletionContributor.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/JetKeywordCompletionContributor.java @@ -36,7 +36,6 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.ProcessingContext; -import com.intellij.util.codeInsight.CommentUtilCore; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lexer.JetToken; @@ -103,7 +102,7 @@ public class JetKeywordCompletionContributor extends CompletionContributor { return false; } - return CommentUtilCore.isComment((PsiElement) element); + return JetPsiUtil.isInComment((PsiElement) element); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java index 13d4e7e8dc5..fb4b1f2dca9 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java +++ b/idea/src/org/jetbrains/jet/plugin/formatter/JetFormattingModelBuilder.java @@ -25,7 +25,6 @@ import com.intellij.psi.codeStyle.CodeStyleSettings; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.kdoc.lexer.KDocTokens; import org.jetbrains.jet.plugin.JetLanguage; import static org.jetbrains.jet.JetNodeTypes.*; @@ -108,9 +107,6 @@ public class JetFormattingModelBuilder implements FormattingModelBuilder { .between(VALUE_ARGUMENT_LIST, FUNCTION_LITERAL_EXPRESSION).spaces(1) .aroundInside(ARROW, WHEN_ENTRY).spaces(1) - - // KDoc - .between(KDocTokens.LEADING_ASTERISK, KDocTokens.TEXT).spacing(1, 100, 0, true, 100) ; } From bcc2c46e99ba1276bd13bc8d96770bc637cf5bcc Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 19:05:01 +0400 Subject: [PATCH 43/92] KDoc wiki links pair matcher and @tags highlighter --- .../org/jetbrains/jet/kdoc/lexer/KDoc.flex | 45 +++- .../jetbrains/jet/kdoc/lexer/KDocTokens.java | 8 + .../jetbrains/jet/kdoc/lexer/_KDocLexer.java | 195 +++++++++++++----- compiler/testData/psi/kdoc/AtTags.jet | 5 + compiler/testData/psi/kdoc/AtTags.txt | 17 ++ compiler/testData/psi/kdoc/Markdown.jet | 4 + compiler/testData/psi/kdoc/Markdown.txt | 20 ++ .../jetbrains/jet/plugin/JetBundle.properties | 2 + .../jetbrains/jet/plugin/JetPairMatcher.java | 6 +- .../highlighter/JetColorSettingsPage.java | 4 +- .../plugin/highlighter/JetHighlighter.java | 7 +- .../highlighter/JetHighlightingColors.java | 2 + .../highlighter/JetHighlightingLexer.java | 15 ++ 13 files changed, 267 insertions(+), 63 deletions(-) create mode 100644 compiler/testData/psi/kdoc/AtTags.jet create mode 100644 compiler/testData/psi/kdoc/AtTags.txt create mode 100644 compiler/testData/psi/kdoc/Markdown.jet create mode 100644 compiler/testData/psi/kdoc/Markdown.txt create mode 100644 idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingLexer.java diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex index 7a1cbd60f21..923e60e53be 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex @@ -4,6 +4,7 @@ import com.intellij.lexer.FlexLexer; import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.util.text.CharArrayUtil; +import java.lang.Character; %% @@ -16,13 +17,21 @@ import com.intellij.util.text.CharArrayUtil; this((java.io.Reader)null); } - private final boolean isLastToken() { + private boolean isLastToken() { return zzMarkedPos == zzBuffer.length(); } - private final Boolean yytextContainLineBreaks() { + private Boolean yytextContainLineBreaks() { return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); } + + private boolean nextIsNotWhitespace() { + return zzMarkedPos <= zzBuffer.length() && !Character.isWhitespace(zzBuffer.charAt(zzMarkedPos + 1)); + } + + private boolean prevIsNotWhitespace() { + return zzMarkedPos != 0 && !Character.isWhitespace(zzBuffer.charAt(zzMarkedPos - 1)); + } %} %function advance @@ -31,12 +40,21 @@ import com.intellij.util.text.CharArrayUtil; return; %eof} -%state CONTENTS %state LINE_BEGINNING +%state CONTENTS_BEGINNING +%state CONTENTS +%state CODE +%state CODE2 WHITE_SPACE_CHAR =[\ \t\f\n\r] NOT_WHITE_SPACE_CHAR=[^\ \t\f\n\r] +DIGIT=[0-9] +ALPHA=[:jletter:] +TAG_NAME={ALPHA}({ALPHA}|{DIGIT})* + +MARKDOWN_EMPHASIS=[\*_] + %% @@ -45,22 +63,33 @@ NOT_WHITE_SPACE_CHAR=[^\ \t\f\n\r] "*"+ "/" { if (isLastToken()) return KDocTokens.END; else return KDocTokens.TEXT; } - "*"+ { yybegin(CONTENTS); + "*"+ { yybegin(CONTENTS_BEGINNING); return KDocTokens.LEADING_ASTERISK; } - { + "@"{TAG_NAME} { yybegin(CONTENTS); + return KDocTokens.TAG_NAME; } + + { {WHITE_SPACE_CHAR}+ { if (yytextContainLineBreaks()) { yybegin(LINE_BEGINNING); return TokenType.WHITE_SPACE; } else { - yybegin(CONTENTS); + yybegin(yystate() == CONTENTS_BEGINNING? CONTENTS_BEGINNING:CONTENTS); return KDocTokens.TEXT; // internal white space } } - . { yybegin(CONTENTS); - return KDocTokens.TEXT; } + "\\"[\[\]] { yybegin(CONTENTS); + return KDocTokens.MARKDOWN_ESCAPED_CHAR; } + + "[[" { yybegin(CONTENTS); + return KDocTokens.WIKI_LINK_OPEN; } + "]]" { yybegin(CONTENTS); + return KDocTokens.WIKI_LINK_CLOSE; } + + . { yybegin(CONTENTS); + return KDocTokens.TEXT; } } . { return TokenType.BAD_CHARACTER; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java index 92bdb3cbb86..da637335958 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDocTokens.java @@ -23,6 +23,7 @@ import com.intellij.lang.PsiParser; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.tree.ILazyParseableElementType; +import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.kdoc.parser.KDocParser; import org.jetbrains.jet.kdoc.psi.impl.KDocImpl; @@ -53,4 +54,11 @@ public interface KDocTokens { KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); KDocToken TEXT = new KDocToken("KDOC_TEXT"); + KDocToken TAG_NAME = new KDocToken("KDOC_TAG_NAME"); + KDocToken WIKI_LINK_OPEN = new KDocToken("KDOC_WIKI_LINK_OPEN"); + KDocToken WIKI_LINK_CLOSE = new KDocToken("KDOC_WIKI_LINK_CLOSE"); + + KDocToken MARKDOWN_ESCAPED_CHAR = new KDocToken("KDOC_MARKDOWN_ESCAPED_CHAR"); + + TokenSet CONTENT_TOKENS = TokenSet.create(START, END, LEADING_ASTERISK, TEXT, WIKI_LINK_OPEN, WIKI_LINK_CLOSE, MARKDOWN_ESCAPED_CHAR); } diff --git a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java index c813e40dc93..373b9284e9a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java +++ b/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/_KDocLexer.java @@ -1,4 +1,4 @@ -/* The following code was generated by JFlex 1.4.3 on 25.05.13 15:08 */ +/* The following code was generated by JFlex 1.4.3 on 25.05.13 16:39 */ package org.jetbrains.jet.kdoc.lexer; @@ -11,7 +11,7 @@ import com.intellij.util.text.CharArrayUtil; /** * This class is a scanner generated by * JFlex 1.4.3 - * on 25.05.13 15:08 from the specification file + * on 25.05.13 16:39 from the specification file * /Users/factitious/Documents/kotlin/compiler/frontend/src/org/jetbrains/jet/kdoc/lexer/KDoc.flex */ class _KDocLexer implements FlexLexer { @@ -19,11 +19,12 @@ class _KDocLexer implements FlexLexer { private static final int ZZ_BUFFERSIZE = 16384; /** lexical states */ - public static final int LINE_BEGINNING = 8; - public static final int STRONG_CONTENTS = 6; - public static final int CONTENTS = 2; + public static final int CODE = 8; + public static final int CONTENTS_BEGINNING = 4; + public static final int CODE2 = 10; + public static final int LINE_BEGINNING = 2; + public static final int CONTENTS = 6; public static final int YYINITIAL = 0; - public static final int EMPHASIS_CONTENTS = 4; /** * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l @@ -32,15 +33,74 @@ class _KDocLexer implements FlexLexer { * l is of the form l = 2*k, k a non negative integer */ private static final int ZZ_LEXSTATE[] = { - 0, 0, 1, 1, 1, 1, 1, 1, 2, 2 + 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4 }; /** * Translates characters to character classes */ private static final String ZZ_CMAP_PACKED = - "\11\0\1\1\1\4\1\0\2\1\22\0\1\1\11\0\1\3\4\0"+ - "\1\2\uffd0\0"; + "\11\0\1\1\1\12\1\0\2\1\22\0\1\1\3\0\1\3\5\0"+ + "\1\4\4\0\1\5\12\2\6\0\1\6\32\3\1\11\1\7\1\10"+ + "\1\0\1\3\1\0\32\3\47\0\4\3\4\0\1\3\12\0\1\3"+ + "\4\0\1\3\5\0\27\3\1\0\37\3\1\0\u013f\3\31\0\162\3"+ + "\4\0\14\3\16\0\5\3\11\0\1\3\213\0\1\3\13\0\1\3"+ + "\1\0\3\3\1\0\1\3\1\0\24\3\1\0\54\3\1\0\46\3"+ + "\1\0\5\3\4\0\202\3\10\0\105\3\1\0\46\3\2\0\2\3"+ + "\6\0\20\3\41\0\46\3\2\0\1\3\7\0\47\3\110\0\33\3"+ + "\5\0\3\3\56\0\32\3\5\0\13\3\43\0\2\3\1\0\143\3"+ + "\1\0\1\3\17\0\2\3\7\0\2\3\12\0\3\3\2\0\1\3"+ + "\20\0\1\3\1\0\36\3\35\0\3\3\60\0\46\3\13\0\1\3"+ + "\u0152\0\66\3\3\0\1\3\22\0\1\3\7\0\12\3\43\0\10\3"+ + "\2\0\2\3\2\0\26\3\1\0\7\3\1\0\1\3\3\0\4\3"+ + "\3\0\1\3\36\0\2\3\1\0\3\3\16\0\4\3\21\0\6\3"+ + "\4\0\2\3\2\0\26\3\1\0\7\3\1\0\2\3\1\0\2\3"+ + "\1\0\2\3\37\0\4\3\1\0\1\3\23\0\3\3\20\0\11\3"+ + "\1\0\3\3\1\0\26\3\1\0\7\3\1\0\2\3\1\0\5\3"+ + "\3\0\1\3\22\0\1\3\17\0\2\3\17\0\1\3\23\0\10\3"+ + "\2\0\2\3\2\0\26\3\1\0\7\3\1\0\2\3\1\0\5\3"+ + "\3\0\1\3\36\0\2\3\1\0\3\3\17\0\1\3\21\0\1\3"+ + "\1\0\6\3\3\0\3\3\1\0\4\3\3\0\2\3\1\0\1\3"+ + "\1\0\2\3\3\0\2\3\3\0\3\3\3\0\10\3\1\0\3\3"+ + "\77\0\1\3\13\0\10\3\1\0\3\3\1\0\27\3\1\0\12\3"+ + "\1\0\5\3\46\0\2\3\43\0\10\3\1\0\3\3\1\0\27\3"+ + "\1\0\12\3\1\0\5\3\3\0\1\3\40\0\1\3\1\0\2\3"+ + "\43\0\10\3\1\0\3\3\1\0\27\3\1\0\20\3\46\0\2\3"+ + "\43\0\22\3\3\0\30\3\1\0\11\3\1\0\1\3\2\0\7\3"+ + "\72\0\60\3\1\0\2\3\13\0\10\3\72\0\2\3\1\0\1\3"+ + "\2\0\2\3\1\0\1\3\2\0\1\3\6\0\4\3\1\0\7\3"+ + "\1\0\3\3\1\0\1\3\1\0\1\3\2\0\2\3\1\0\4\3"+ + "\1\0\2\3\11\0\1\3\2\0\5\3\1\0\1\3\25\0\2\3"+ + "\42\0\1\3\77\0\10\3\1\0\42\3\35\0\4\3\164\0\42\3"+ + "\1\0\5\3\1\0\2\3\45\0\6\3\112\0\46\3\12\0\51\3"+ + "\7\0\132\3\5\0\104\3\5\0\122\3\6\0\7\3\1\0\77\3"+ + "\1\0\1\3\1\0\4\3\2\0\7\3\1\0\1\3\1\0\4\3"+ + "\2\0\47\3\1\0\1\3\1\0\4\3\2\0\37\3\1\0\1\3"+ + "\1\0\4\3\2\0\7\3\1\0\1\3\1\0\4\3\2\0\7\3"+ + "\1\0\7\3\1\0\27\3\1\0\37\3\1\0\1\3\1\0\4\3"+ + "\2\0\7\3\1\0\47\3\1\0\23\3\105\0\125\3\14\0\u026c\3"+ + "\2\0\10\3\12\0\32\3\5\0\113\3\3\0\3\3\17\0\15\3"+ + "\1\0\4\3\16\0\22\3\16\0\22\3\16\0\15\3\1\0\3\3"+ + "\17\0\64\3\43\0\1\3\3\0\2\3\103\0\130\3\10\0\51\3"+ + "\127\0\35\3\63\0\36\3\2\0\5\3\u038b\0\154\3\224\0\234\3"+ + "\4\0\132\3\6\0\26\3\2\0\6\3\2\0\46\3\2\0\6\3"+ + "\2\0\10\3\1\0\1\3\1\0\1\3\1\0\1\3\1\0\37\3"+ + "\2\0\65\3\1\0\7\3\1\0\1\3\3\0\3\3\1\0\7\3"+ + "\3\0\4\3\2\0\6\3\4\0\15\3\5\0\3\3\1\0\7\3"+ + "\102\0\2\3\23\0\1\3\34\0\1\3\15\0\1\3\40\0\22\3"+ + "\120\0\1\3\4\0\1\3\2\0\12\3\1\0\1\3\3\0\5\3"+ + "\6\0\1\3\1\0\1\3\1\0\1\3\1\0\4\3\1\0\3\3"+ + "\1\0\7\3\3\0\3\3\5\0\5\3\26\0\44\3\u0e81\0\3\3"+ + "\31\0\11\3\7\0\5\3\2\0\5\3\4\0\126\3\6\0\3\3"+ + "\1\0\137\3\5\0\50\3\4\0\136\3\21\0\30\3\70\0\20\3"+ + "\u0200\0\u19b6\3\112\0\u51a6\3\132\0\u048d\3\u0773\0\u2ba4\3\u215c\0\u012e\3"+ + "\2\0\73\3\225\0\7\3\14\0\5\3\5\0\1\3\1\0\12\3"+ + "\1\0\15\3\1\0\5\3\1\0\1\3\1\0\2\3\1\0\2\3"+ + "\1\0\154\3\41\0\u016b\3\22\0\100\3\2\0\66\3\50\0\15\3"+ + "\66\0\2\3\30\0\3\3\31\0\1\3\6\0\5\3\1\0\207\3"+ + "\7\0\1\3\34\0\32\3\4\0\1\3\1\0\32\3\12\0\132\3"+ + "\3\0\6\3\2\0\6\3\2\0\6\3\2\0\3\3\3\0\2\3"+ + "\3\0\2\3\31\0"; /** * Translates characters to character classes @@ -53,11 +113,11 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_ACTION = zzUnpackAction(); private static final String ZZ_ACTION_PACKED_0 = - "\3\0\3\1\1\2\1\3\1\2\1\4\1\0\1\5"+ - "\1\0\1\6"; + "\5\0\3\1\1\2\1\3\1\4\5\2\1\0\1\5"+ + "\1\0\1\6\1\7\1\10\1\11\1\12"; private static int [] zzUnpackAction() { - int [] result = new int[14]; + int [] result = new int[24]; int offset = 0; offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); return result; @@ -82,11 +142,12 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); private static final String ZZ_ROWMAP_PACKED_0 = - "\0\0\0\5\0\12\0\17\0\24\0\31\0\17\0\36"+ - "\0\31\0\43\0\50\0\17\0\31\0\17"; + "\0\0\0\13\0\26\0\41\0\54\0\67\0\102\0\115"+ + "\0\67\0\130\0\143\0\156\0\171\0\204\0\102\0\217"+ + "\0\102\0\67\0\232\0\67\0\67\0\67\0\245\0\67"; private static int [] zzUnpackRowMap() { - int [] result = new int[14]; + int [] result = new int[24]; int offset = 0; offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); return result; @@ -109,13 +170,17 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_TRANS = zzUnpackTrans(); private static final String ZZ_TRANS_PACKED_0 = - "\2\4\1\5\1\6\1\0\1\7\1\10\1\7\1\11"+ - "\1\10\1\7\1\10\1\7\1\12\1\10\10\0\1\13"+ - "\3\0\1\14\1\15\2\0\1\10\2\0\1\10\2\0"+ - "\1\14\1\12\4\0\1\16\1\0"; + "\4\6\1\7\1\10\4\6\1\0\1\11\1\12\2\11"+ + "\1\13\2\11\1\14\1\15\1\16\1\12\1\11\1\12"+ + "\2\11\1\17\1\11\1\20\1\14\1\15\1\16\1\12"+ + "\1\11\1\12\2\11\1\17\2\11\1\14\1\15\1\16"+ + "\1\12\4\6\1\7\5\6\20\0\1\21\1\22\11\0"+ + "\1\23\7\0\1\12\10\0\1\12\4\0\1\13\1\22"+ + "\15\0\2\24\11\0\1\25\13\0\1\26\4\0\1\27"+ + "\13\0\1\30\10\0\2\27\7\0"; private static int [] zzUnpackTrans() { - int [] result = new int[45]; + int [] result = new int[176]; int offset = 0; offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); return result; @@ -156,11 +221,11 @@ class _KDocLexer implements FlexLexer { private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); private static final String ZZ_ATTRIBUTE_PACKED_0 = - "\3\0\1\11\2\1\1\11\3\1\1\0\1\11\1\0"+ - "\1\11"; + "\5\0\1\11\2\1\1\11\7\1\1\0\1\11\1\0"+ + "\3\11\1\1\1\11"; private static int [] zzUnpackAttribute() { - int [] result = new int[14]; + int [] result = new int[24]; int offset = 0; offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); return result; @@ -223,14 +288,22 @@ class _KDocLexer implements FlexLexer { this((java.io.Reader)null); } - private final boolean isLastToken() { + private boolean isLastToken() { return zzMarkedPos == zzBuffer.length(); } - private final Boolean yytextContainLineBreaks() { + private Boolean yytextContainLineBreaks() { return CharArrayUtil.containLineBreaks(zzBuffer, zzStartRead, zzMarkedPos); } + private boolean nextIsNotWhitespace() { + return zzMarkedPos <= zzBuffer.length() && !Character.isWhitespace(zzBuffer.charAt(zzMarkedPos + 1)); + } + + private boolean prevIsNotWhitespace() { + return zzMarkedPos != 0 && !Character.isWhitespace(zzBuffer.charAt(zzMarkedPos - 1)); + } + _KDocLexer(java.io.Reader in) { this.zzReader = in; @@ -256,7 +329,7 @@ class _KDocLexer implements FlexLexer { char [] map = new char[0x10000]; int i = 0; /* index in packed string */ int j = 0; /* index in unpacked array */ - while (i < 24) { + while (i < 1206) { int count = packed.charAt(i++); char value = packed.charAt(i++); do map[j++] = value; while (--count > 0); @@ -479,40 +552,60 @@ class _KDocLexer implements FlexLexer { zzMarkedPos = zzMarkedPosL; switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { - case 6: - { yybegin(CONTENTS); - return KDocTokens.START; - } - case 7: break; - case 5: - { if (isLastToken()) return KDocTokens.END; - else return KDocTokens.TEXT; - } - case 8: break; - case 1: - { return TokenType.BAD_CHARACTER; - } - case 9: break; - case 2: - { yybegin(CONTENTS); - return KDocTokens.TEXT; - } - case 10: break; - case 4: - { yybegin(CONTENTS); - return KDocTokens.LEADING_ASTERISK; - } - case 11: break; case 3: { if (yytextContainLineBreaks()) { yybegin(LINE_BEGINNING); return TokenType.WHITE_SPACE; } else { - yybegin(CONTENTS); + yybegin(yystate() == CONTENTS_BEGINNING? CONTENTS_BEGINNING:CONTENTS); return KDocTokens.TEXT; // internal white space } } + case 11: break; + case 5: + { if (isLastToken()) return KDocTokens.END; + else return KDocTokens.TEXT; + } case 12: break; + case 9: + { yybegin(CONTENTS); + return KDocTokens.TAG_NAME; + } + case 13: break; + case 7: + { yybegin(CONTENTS); + return KDocTokens.WIKI_LINK_CLOSE; + } + case 14: break; + case 8: + { yybegin(CONTENTS); + return KDocTokens.WIKI_LINK_OPEN; + } + case 15: break; + case 10: + { yybegin(CONTENTS); + return KDocTokens.START; + } + case 16: break; + case 1: + { return TokenType.BAD_CHARACTER; + } + case 17: break; + case 6: + { yybegin(CONTENTS); + return KDocTokens.MARKDOWN_ESCAPED_CHAR; + } + case 18: break; + case 2: + { yybegin(CONTENTS); + return KDocTokens.TEXT; + } + case 19: break; + case 4: + { yybegin(CONTENTS_BEGINNING); + return KDocTokens.LEADING_ASTERISK; + } + case 20: break; default: if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { zzAtEOF = true; diff --git a/compiler/testData/psi/kdoc/AtTags.jet b/compiler/testData/psi/kdoc/AtTags.jet new file mode 100644 index 00000000000..8798fcad57b --- /dev/null +++ b/compiler/testData/psi/kdoc/AtTags.jet @@ -0,0 +1,5 @@ +/** + * @tag + * text @notATag + * @ + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/AtTags.txt b/compiler/testData/psi/kdoc/AtTags.txt new file mode 100644 index 00000000000..8e1dd8be825 --- /dev/null +++ b/compiler/testData/psi/kdoc/AtTags.txt @@ -0,0 +1,17 @@ +JetFile: AtTags.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)(' ') + PsiElement(KDOC_TAG_NAME)('@tag') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)(' text @notATag') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)(' @') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Markdown.jet b/compiler/testData/psi/kdoc/Markdown.jet new file mode 100644 index 00000000000..8811d83ea2e --- /dev/null +++ b/compiler/testData/psi/kdoc/Markdown.jet @@ -0,0 +1,4 @@ +/** + * [[WikiLink]] + * Just \[[ and \]] + */ \ No newline at end of file diff --git a/compiler/testData/psi/kdoc/Markdown.txt b/compiler/testData/psi/kdoc/Markdown.txt new file mode 100644 index 00000000000..6755464bcff --- /dev/null +++ b/compiler/testData/psi/kdoc/Markdown.txt @@ -0,0 +1,20 @@ +JetFile: Markdown.jet + KDoc + PsiElement(KDOC_START)('/**') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)(' ') + PsiElement(KDOC_WIKI_LINK_OPEN)('[[') + PsiElement(KDOC_TEXT)('WikiLink') + PsiElement(KDOC_WIKI_LINK_CLOSE)(']]') + PsiWhiteSpace('\n ') + PsiElement(KDOC_LEADING_ASTERISK)('*') + PsiElement(KDOC_TEXT)(' Just ') + PsiElement(KDOC_MARKDOWN_ESCAPED_CHAR)('\[') + PsiElement(KDOC_TEXT)('[ and ') + PsiElement(KDOC_MARKDOWN_ESCAPED_CHAR)('\]') + PsiElement(KDOC_TEXT)(']') + PsiWhiteSpace('\n ') + PsiElement(KDOC_END)('*/') + NAMESPACE_HEADER + \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index 9536b7af1f7..c640470d94b 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -110,6 +110,8 @@ options.jet.attribute.descriptor.closure.braces=Function literal braces and arro options.jet.attribute.descriptor.safe.access=Safe access dot options.jet.attribute.descriptor.arrow=Arrow options.jet.attribute.descriptor.kdoc.comment=KDoc comment +options.jet.attribute.descriptor.kdoc.tag=KDoc tag +options.jet.attribute.descriptor.kdoc.value=KDoc tag value options.jet.attribute.descriptor.trait=Trait options.jet.attribute.descriptor.annotation=Annotation options.jet.attribute.descriptor.var=Var (mutable variable, parameter or property) diff --git a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java index 9bf05aa432b..40dd0154b1f 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPairMatcher.java @@ -22,6 +22,7 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; import org.jetbrains.jet.lexer.JetTokens; public class JetPairMatcher implements PairedBraceMatcher { @@ -29,7 +30,8 @@ public class JetPairMatcher implements PairedBraceMatcher { new BracePair(JetTokens.LPAR, JetTokens.RPAR, false), new BracePair(JetTokens.LONG_TEMPLATE_ENTRY_START, JetTokens.LONG_TEMPLATE_ENTRY_END, false), new BracePair(JetTokens.LBRACE, JetTokens.RBRACE, true), - new BracePair(JetTokens.LBRACKET, JetTokens.RBRACKET, false) + new BracePair(JetTokens.LBRACKET, JetTokens.RBRACKET, false), + new BracePair(KDocTokens.WIKI_LINK_OPEN, KDocTokens.WIKI_LINK_CLOSE, false) }; @Override @@ -44,6 +46,8 @@ public class JetPairMatcher implements PairedBraceMatcher { return false; } + if (lbraceType == KDocTokens.WIKI_LINK_OPEN) return false; + return JetTokens.WHITE_SPACE_OR_COMMENT_BIT_SET.contains(contextType) || contextType == JetTokens.SEMICOLON || contextType == JetTokens.COMMA diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetColorSettingsPage.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetColorSettingsPage.java index c39db363ffd..c3ac0bccda9 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetColorSettingsPage.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetColorSettingsPage.java @@ -54,7 +54,7 @@ public class JetColorSettingsPage implements ColorSettingsPage { "\n" + "/**\n" + " * Doc comment here for `SomeClass`\n" + - " * @see Iterator#next()\n" + + " * @see Iterator#next()\n" + " */\n" + "[Deprecated]\n" + "public class MyClass<out T : Iterable<T>>(var prop1 : Int) {\n" + @@ -126,6 +126,8 @@ public class JetColorSettingsPage implements ColorSettingsPage { new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.block.comment"), JetHighlightingColors.BLOCK_COMMENT), new AttributesDescriptor(JetBundle.message("options.jet.attribute.descriptor.kdoc.comment"), JetHighlightingColors.DOC_COMMENT), + new AttributesDescriptor(JetBundle.message("options.jet.attribute.descriptor.kdoc.tag"), JetHighlightingColors.KDOC_TAG), + new AttributesDescriptor(JetBundle.message("options.jet.attribute.descriptor.kdoc.value"), JetHighlightingColors.KDOC_TAG_VALUE), new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.class"), JetHighlightingColors.CLASS), new AttributesDescriptor(OptionsBundle.message("options.java.attribute.descriptor.type.parameter"), JetHighlightingColors.TYPE_PARAMETER), diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlighter.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlighter.java index d4452953aab..8b649b2ff68 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlighter.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlighter.java @@ -23,7 +23,7 @@ import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lexer.JetLexer; +import org.jetbrains.jet.kdoc.lexer.KDocTokens; import org.jetbrains.jet.lexer.JetTokens; import java.util.HashMap; @@ -34,7 +34,7 @@ public class JetHighlighter extends SyntaxHighlighterBase { @NotNull public Lexer getHighlightingLexer() { - return new JetLexer(); + return new JetHighlightingLexer(); } @NotNull @@ -83,6 +83,9 @@ public class JetHighlighter extends SyntaxHighlighterBase { keys.put(JetTokens.BLOCK_COMMENT, JetHighlightingColors.BLOCK_COMMENT); keys.put(JetTokens.DOC_COMMENT, JetHighlightingColors.DOC_COMMENT); + fillMap(keys, KDocTokens.CONTENT_TOKENS, JetHighlightingColors.DOC_COMMENT); + keys.put(KDocTokens.TAG_NAME, JetHighlightingColors.KDOC_TAG); + keys.put(TokenType.BAD_CHARACTER, JetHighlightingColors.BAD_CHARACTER); } } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingColors.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingColors.java index e7d1bfad66a..4230cc48b03 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingColors.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingColors.java @@ -44,6 +44,8 @@ public class JetHighlightingColors { public static final TextAttributesKey LINE_COMMENT = createTextAttributesKey("KOTLIN_LINE_COMMENT", DefaultLanguageHighlighterColors.LINE_COMMENT); public static final TextAttributesKey BLOCK_COMMENT = createTextAttributesKey("KOTLIN_BLOCK_COMMENT", DefaultLanguageHighlighterColors.BLOCK_COMMENT); public static final TextAttributesKey DOC_COMMENT = createTextAttributesKey("KOTLIN_DOC_COMMENT", DefaultLanguageHighlighterColors.DOC_COMMENT); + public static final TextAttributesKey KDOC_TAG = createTextAttributesKey("KDOC_TAG_NAME", DefaultLanguageHighlighterColors.DOC_COMMENT_TAG); + public static final TextAttributesKey KDOC_TAG_VALUE = createTextAttributesKey("KDOC_TAG_VALUE", DefaultLanguageHighlighterColors.DOC_COMMENT_TAG_VALUE); // class kinds public static final TextAttributesKey CLASS = createTextAttributesKey("KOTLIN_CLASS", CodeInsightColors.CLASS_NAME_ATTRIBUTES); diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingLexer.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingLexer.java new file mode 100644 index 00000000000..9e178dd5b1a --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetHighlightingLexer.java @@ -0,0 +1,15 @@ +package org.jetbrains.jet.plugin.highlighter; + +import com.intellij.lexer.LayeredLexer; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.jet.kdoc.lexer.KDocLexer; +import org.jetbrains.jet.lexer.JetLexer; +import org.jetbrains.jet.lexer.JetTokens; + +public class JetHighlightingLexer extends LayeredLexer { + public JetHighlightingLexer() { + super(new JetLexer()); + + registerSelfStoppingLayer(new KDocLexer(), new IElementType[]{JetTokens.DOC_COMMENT}, IElementType.EMPTY_ARRAY); + } +} From 7b6505e54f9709a0fa8e0178a1f9dc91183bc3a0 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Tue, 28 May 2013 15:55:57 +0400 Subject: [PATCH 44/92] Fixed 'lowercaseFirstLetter' for test data in 280 pull request --- idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java b/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java index 967ef967b7d..fd630cfd199 100644 --- a/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java +++ b/idea/tests/org/jetbrains/jet/editor/JetCommenterTest.java @@ -43,11 +43,11 @@ public class JetCommenterTest extends LightCodeInsightTestCase { } private void configure() throws Exception { - configureFromFileText("a.kt", loadFile(getTestName(false) + ".kt")); + configureFromFileText("a.kt", loadFile(getTestName(true) + ".kt")); } private void check() throws Exception { - checkResultByText(loadFile(getTestName(false) + "_after.kt")); + checkResultByText(loadFile(getTestName(true) + "_after.kt")); } protected static String loadFile(String name) throws Exception { From b7a99ac27244143b284294a4caf589389c54827e Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:07 +0400 Subject: [PATCH 45/92] Added my dictionary with "klass" word. --- .idea/dictionaries/geevee.xml | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 .idea/dictionaries/geevee.xml diff --git a/.idea/dictionaries/geevee.xml b/.idea/dictionaries/geevee.xml new file mode 100644 index 00000000000..a295409b23b --- /dev/null +++ b/.idea/dictionaries/geevee.xml @@ -0,0 +1,7 @@ + + + + klass + + + \ No newline at end of file From fcf990d80da52d500666c0c51ab432b854207df0 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:32 +0400 Subject: [PATCH 46/92] Cleanup in .gitignore --- .gitignore | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/.gitignore b/.gitignore index daef9f5114c..11d3561b490 100644 --- a/.gitignore +++ b/.gitignore @@ -1,23 +1,12 @@ -compiler/frontend/idea.properties -examples/.idea/dictionaries -examples/.idea/workspace.xml -examples/example-vfs/.idea/workspace.xml -libraries/.idea/workspace.xml -confluence/target confluence/target pluginPublisher/plugin-verifier.jar pluginPublisher/idea* -patches-master out dist ideaSDK dependencies -.idea/dictionaries/yozh.xml .idea/workspace.xml tmp -*TestMy.java -.*.swp gh-pages -*.class .DS_Store android.tests.dependencies \ No newline at end of file From 79b904020d9d799102b95cc4215a119895c4f5fa Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:45 +0400 Subject: [PATCH 47/92] Sorted .gitignore --- .gitignore | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/.gitignore b/.gitignore index 11d3561b490..dd9b42ffd43 100644 --- a/.gitignore +++ b/.gitignore @@ -1,12 +1,12 @@ -confluence/target -pluginPublisher/plugin-verifier.jar -pluginPublisher/idea* -out -dist -ideaSDK -dependencies -.idea/workspace.xml -tmp -gh-pages .DS_Store -android.tests.dependencies \ No newline at end of file +.idea/workspace.xml +android.tests.dependencies +confluence/target +dependencies +dist +gh-pages +ideaSDK +out +pluginPublisher/idea* +pluginPublisher/plugin-verifier.jar +tmp \ No newline at end of file From 68d8716ba8e3453a15c2a66a8eabfdfa0e8b843c Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 20:06:39 +0400 Subject: [PATCH 48/92] Ignoring all workspace.xml files. --- .gitignore | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index dd9b42ffd43..7922f383f52 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ .DS_Store -.idea/workspace.xml android.tests.dependencies confluence/target dependencies @@ -9,4 +8,5 @@ ideaSDK out pluginPublisher/idea* pluginPublisher/plugin-verifier.jar -tmp \ No newline at end of file +tmp +workspace.xml \ No newline at end of file From 35fa071e1b31b3c0c6f89fc07d20490c5a63a62e Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Tue, 30 Apr 2013 19:32:21 +0200 Subject: [PATCH 49/92] Better behaviour of "Change Type" quickfixes in case of function types --- .../plugin/quickfix/CastExpressionFix.java | 9 ++++-- .../quickfix/ChangeAccessorTypeFix.java | 30 +++++++++---------- .../quickfix/ChangeFunctionReturnTypeFix.java | 9 ++++-- .../jet/plugin/quickfix/ChangeTypeFix.java | 9 +++--- .../quickfix/ChangeVariableTypeFix.java | 9 +++--- ...ngeOverridingPropertyTypeToFunctionType.kt | 7 +++++ ...ngeOverridingPropertyTypeToFunctionType.kt | 7 +++++ .../afterChangeAccessorTypeToFunctionType.kt | 5 ++++ .../beforeChangeAccessorTypeToFunctionType.kt | 5 ++++ ...ctionLiteralParameterTypeToFunctionType.kt | 6 ++++ ...rChangeFunctionReturnTypeToFunctionType.kt | 4 +++ ...ctionLiteralParameterTypeToFunctionType.kt | 6 ++++ ...eChangeFunctionReturnTypeToFunctionType.kt | 4 +++ .../casts/afterCastToFunctionType.kt | 4 +++ .../casts/beforeCastToFunctionType.kt | 4 +++ .../quickfix/QuickFixTestGenerated.java | 25 ++++++++++++++++ 16 files changed, 113 insertions(+), 30 deletions(-) create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverridingPropertyTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeAddition/afterChangeAccessorTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeAddition/beforeChangeAccessorTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/afterChangeFunctionLiteralParameterTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/casts/afterCastToFunctionType.kt create mode 100644 idea/testData/quickfix/typeMismatch/casts/beforeCastToFunctionType.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java index 1b4cc20a134..9d96a551817 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java @@ -33,19 +33,22 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; +import org.jetbrains.jet.renderer.DescriptorRenderer; public class CastExpressionFix extends JetIntentionAction { private final JetType type; + private final String renderedType; public CastExpressionFix(@NotNull JetExpression element, @NotNull JetType type) { super(element); this.type = type; + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); } @NotNull @Override public String getText() { - return JetBundle.message("cast.expression.to.type", element.getText(), type.toString()); + return JetBundle.message("cast.expression.to.type", element.getText(), renderedType); } @NotNull @@ -64,9 +67,9 @@ public class CastExpressionFix extends JetIntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { JetBinaryExpressionWithTypeRHS castedExpression = - (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, "(" + element.getText() + ") as " + type.toString()); + (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, "(" + element.getText() + ") as " + renderedType); if (JetPsiUtil.areParenthesesUseless((JetParenthesizedExpression) castedExpression.getLeft())) { - castedExpression = (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, element.getText() + " as " + type.toString()); + castedExpression = (JetBinaryExpressionWithTypeRHS) JetPsiFactory.createExpression(project, element.getText() + " as " + renderedType); } JetParenthesizedExpression castedExpressionInParentheses = diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java index 102874d7f83..6eef4a97ffe 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java @@ -23,38 +23,38 @@ import com.intellij.psi.impl.source.codeStyle.CodeEditUtil; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.renderer.DescriptorRenderer; public class ChangeAccessorTypeFix extends JetIntentionAction { + private String renderedType; + public ChangeAccessorTypeFix(@NotNull JetPropertyAccessor element) { super(element); } - @Nullable - private JetType getPropertyType() { - JetProperty property = PsiTreeUtil.getParentOfType(element, JetProperty.class); - if (property == null) return null; - return QuickFixUtil.getDeclarationReturnType(property); - } - @Override public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { - JetType type = getPropertyType(); - return super.isAvailable(project, editor, file) && type != null && !ErrorUtils.isErrorType(type); + JetProperty property = PsiTreeUtil.getParentOfType(element, JetProperty.class); + if (property == null) return false; + JetType type = QuickFixUtil.getDeclarationReturnType(property); + if (super.isAvailable(project, editor, file) && type != null && !ErrorUtils.isErrorType(type)) { + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); + return true; + } + return false; } @NotNull @Override public String getText() { - JetType type = getPropertyType(); return element.isGetter() - ? JetBundle.message("change.getter.type", type) - : JetBundle.message("change.setter.type", type); + ? JetBundle.message("change.getter.type", renderedType) + : JetBundle.message("change.setter.type", renderedType); } @NotNull @@ -65,10 +65,8 @@ public class ChangeAccessorTypeFix extends JetIntentionAction { private final JetType type; + private final String renderedType; public ChangeFunctionReturnTypeFix(@NotNull JetNamedFunction element, @NotNull JetType type) { super(element); this.type = type; + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); } @NotNull @@ -65,8 +68,8 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction { - private final JetType type; + private final String renderedType; public ChangeTypeFix(@NotNull JetTypeReference element, JetType type) { super(element); - this.type = type; + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); } @NotNull @Override public String getText() { - return JetBundle.message("change.type", element.getText(), type); + return JetBundle.message("change.type", element.getText(), renderedType); } @NotNull @@ -54,7 +55,7 @@ public class ChangeTypeFix extends JetIntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { - element.replace(JetPsiFactory.createType(project, type.toString())); + element.replace(JetPsiFactory.createType(project, renderedType)); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index c3423fa6b28..92e7d23ea82 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -36,19 +36,20 @@ import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; +import org.jetbrains.jet.renderer.DescriptorRenderer; public class ChangeVariableTypeFix extends JetIntentionAction { - private final JetType type; + private final String renderedType; public ChangeVariableTypeFix(@NotNull JetVariableDeclaration element, @NotNull JetType type) { super(element); - this.type = type; + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); } @NotNull @Override public String getText() { - return JetBundle.message("change.element.type", element.getName(), type); + return JetBundle.message("change.element.type", element.getName(), renderedType); } @NotNull @@ -62,7 +63,7 @@ public class ChangeVariableTypeFix extends JetIntentionAction typeWhiteSpaceAndColon = JetPsiFactory.createTypeWhiteSpaceAndColon(project, type.toString()); + Pair typeWhiteSpaceAndColon = JetPsiFactory.createTypeWhiteSpaceAndColon(project, renderedType); element.addRangeAfter(typeWhiteSpaceAndColon.first, typeWhiteSpaceAndColon.second, nameIdentifier); } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverridingPropertyTypeToFunctionType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverridingPropertyTypeToFunctionType.kt new file mode 100644 index 00000000000..dea0db239e9 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverridingPropertyTypeToFunctionType.kt @@ -0,0 +1,7 @@ +// "Change 'x' type to '(String) -> Int'" "true" +trait A { + var x: (String) -> Int +} +trait B : A { + override var x: (String) -> Int +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt new file mode 100644 index 00000000000..86cf8bd43da --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt @@ -0,0 +1,7 @@ +// "Change 'x' type to '(String) -> Int'" "true" +trait A { + var x: (String) -> Int +} +trait B : A { + override var x: (Int) -> String +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeAddition/afterChangeAccessorTypeToFunctionType.kt b/idea/testData/quickfix/typeAddition/afterChangeAccessorTypeToFunctionType.kt new file mode 100644 index 00000000000..642223733a3 --- /dev/null +++ b/idea/testData/quickfix/typeAddition/afterChangeAccessorTypeToFunctionType.kt @@ -0,0 +1,5 @@ +// "Change getter type to (String) -> Int" "true" +class A { + val x: (String) -> Int + get(): (String) -> Int = {42} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeAddition/beforeChangeAccessorTypeToFunctionType.kt b/idea/testData/quickfix/typeAddition/beforeChangeAccessorTypeToFunctionType.kt new file mode 100644 index 00000000000..2a070579945 --- /dev/null +++ b/idea/testData/quickfix/typeAddition/beforeChangeAccessorTypeToFunctionType.kt @@ -0,0 +1,5 @@ +// "Change getter type to (String) -> Int" "true" +class A { + val x: (String) -> Int + get(): Int = {42} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/afterChangeFunctionLiteralParameterTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/afterChangeFunctionLiteralParameterTypeToFunctionType.kt new file mode 100644 index 00000000000..89a07f91281 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/afterChangeFunctionLiteralParameterTypeToFunctionType.kt @@ -0,0 +1,6 @@ +// "Change type from 'String' to '(Int) -> String'" "true" +fun foo(f: ((Int) -> String) -> String) { + foo { + (f: (Int) -> String) -> f(42) + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt new file mode 100644 index 00000000000..4d6e718b946 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt @@ -0,0 +1,4 @@ +// "Change 'foo' function return type to '(Long) -> Int'" "true" +fun foo(x: Any): (Long) -> Int { + return {(x: Long) -> 42} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt new file mode 100644 index 00000000000..c8897d3a65e --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt @@ -0,0 +1,6 @@ +// "Change type from 'String' to '(Int) -> String'" "true" +fun foo(f: ((Int) -> String) -> String) { + foo { + (f: String) -> f(42) + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt new file mode 100644 index 00000000000..2f90f8ee5e5 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt @@ -0,0 +1,4 @@ +// "Change 'foo' function return type to '(Long) -> Int'" "true" +fun foo(x: Any): Int { + return {(x: Long) -> 42} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/casts/afterCastToFunctionType.kt b/idea/testData/quickfix/typeMismatch/casts/afterCastToFunctionType.kt new file mode 100644 index 00000000000..989e55304cf --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/casts/afterCastToFunctionType.kt @@ -0,0 +1,4 @@ +// "Cast expression 'x' to '() -> Int'" "true" +fun foo(x: Any): () -> Int { + return x as () -> Int +} diff --git a/idea/testData/quickfix/typeMismatch/casts/beforeCastToFunctionType.kt b/idea/testData/quickfix/typeMismatch/casts/beforeCastToFunctionType.kt new file mode 100644 index 00000000000..eb0f35b50c3 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/casts/beforeCastToFunctionType.kt @@ -0,0 +1,4 @@ +// "Cast expression 'x' to '() -> Int'" "true" +fun foo(x: Any): () -> Int { + return x +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 350eaa4bd87..0d9ee817a72 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1018,6 +1018,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^before(\\w+)\\.kt$"), true); } + @TestMetadata("beforeChangeOverridingPropertyTypeToFunctionType.kt") + public void testChangeOverridingPropertyTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt"); + } + @TestMetadata("beforePropertyReturnTypeMismatchOnOverride.kt") public void testPropertyReturnTypeMismatchOnOverride() throws Exception { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt"); @@ -1149,6 +1154,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeAddition/beforeAmbiguousPropertyReturnType.kt"); } + @TestMetadata("beforeChangeAccessorTypeToFunctionType.kt") + public void testChangeAccessorTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeAddition/beforeChangeAccessorTypeToFunctionType.kt"); + } + @TestMetadata("beforeNoAddErrorType.kt") public void testNoAddErrorType() throws Exception { doTest("idea/testData/quickfix/typeAddition/beforeNoAddErrorType.kt"); @@ -1236,6 +1246,16 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); } + @TestMetadata("beforeChangeFunctionReturnTypeToFunctionType.kt") + public void testChangeFunctionReturnTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt"); + } + + @TestMetadata("beforeChangeParameterTypeToFunctionType.kt") + public void testChangeParameterTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforeChangeParameterTypeToFunctionType.kt"); + } + @TestMetadata("beforeChangeReturnTypeWhenFunctionNameIsMissing.kt") public void testChangeReturnTypeWhenFunctionNameIsMissing() throws Exception { doTest("idea/testData/quickfix/typeMismatch/beforeChangeReturnTypeWhenFunctionNameIsMissing.kt"); @@ -1332,6 +1352,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/casts/beforeAutocastImpossible3.kt"); } + @TestMetadata("beforeCastToFunctionType.kt") + public void testCastToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/casts/beforeCastToFunctionType.kt"); + } + @TestMetadata("beforeTypeMismatch1.kt") public void testTypeMismatch1() throws Exception { doTest("idea/testData/quickfix/typeMismatch/casts/beforeTypeMismatch1.kt"); From 07ea3183612042d741162a05499f7ae573935461 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 1 May 2013 18:22:40 +0200 Subject: [PATCH 50/92] Get rid of warnings in "Change Type" quickfixes --- .../jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java | 4 ++-- idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java | 4 ++-- .../jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java | 3 +-- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java index 0c4177e7911..3ae4dff778e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java @@ -22,7 +22,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiErrorElement; -import com.intellij.psi.PsiFile; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -79,7 +78,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction) diagnostic).getA().asString(); int componentIndex = Integer.valueOf(componentName.substring(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX.length())); JetMultiDeclaration multiDeclaration = QuickFixUtil.getParentElementOfType(diagnostic, JetMultiDeclaration.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java index 717179f49fd..318b74b0015 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeTypeFix.java @@ -19,13 +19,13 @@ 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.PsiFile; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters1; import org.jetbrains.jet.lang.diagnostics.Errors; +import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetParameter; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetTypeReference; @@ -54,7 +54,7 @@ public class ChangeTypeFix extends JetIntentionAction { } @Override - public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { + public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { element.replace(JetPsiFactory.createType(project, renderedType)); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index 92e7d23ea82..3236e846711 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -21,7 +21,6 @@ import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -59,7 +58,7 @@ public class ChangeVariableTypeFix extends JetIntentionAction Date: Wed, 1 May 2013 19:30:43 +0200 Subject: [PATCH 51/92] Cleanup in "type mismatch" tests --- ...terComponentFunctionReturnTypeMismatch1.kt | 0 ...terComponentFunctionReturnTypeMismatch2.kt | 0 ...terComponentFunctionReturnTypeMismatch3.kt | 0 ...terComponentFunctionReturnTypeMismatch4.kt | 0 ...terComponentFunctionReturnTypeMismatch5.kt | 0 ...oreComponentFunctionReturnTypeMismatch1.kt | 0 ...oreComponentFunctionReturnTypeMismatch2.kt | 0 ...oreComponentFunctionReturnTypeMismatch3.kt | 0 ...oreComponentFunctionReturnTypeMismatch4.kt | 0 ...oreComponentFunctionReturnTypeMismatch5.kt | 0 ...rChangeFunctionReturnTypeToFunctionType.kt | 0 .../afterTypeMismatchInInitializer.kt | 0 .../afterTypeMismatchInReturnStatement.kt | 0 ...eChangeFunctionReturnTypeToFunctionType.kt | 0 .../beforeTypeMismatchInInitializer.kt | 0 .../beforeTypeMismatchInReturnStatement.kt | 0 .../quickfix/QuickFixTestGenerated.java | 106 ++++++++++-------- 17 files changed, 62 insertions(+), 44 deletions(-) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/afterComponentFunctionReturnTypeMismatch1.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/afterComponentFunctionReturnTypeMismatch2.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/afterComponentFunctionReturnTypeMismatch3.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/afterComponentFunctionReturnTypeMismatch4.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/afterComponentFunctionReturnTypeMismatch5.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/beforeComponentFunctionReturnTypeMismatch1.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/beforeComponentFunctionReturnTypeMismatch2.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/beforeComponentFunctionReturnTypeMismatch3.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/beforeComponentFunctionReturnTypeMismatch4.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => componentFunctionReturnTypeMismatch}/beforeComponentFunctionReturnTypeMismatch5.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/afterChangeFunctionReturnTypeToFunctionType.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/afterTypeMismatchInInitializer.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/afterTypeMismatchInReturnStatement.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/beforeChangeFunctionReturnTypeToFunctionType.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/beforeTypeMismatchInInitializer.kt (100%) rename idea/testData/quickfix/typeMismatch/{ => typeMismatchOnReturnedExpression}/beforeTypeMismatchInReturnStatement.kt (100%) diff --git a/idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch1.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch1.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch1.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch1.kt diff --git a/idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch2.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch2.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch2.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch2.kt diff --git a/idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch3.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch3.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch3.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch3.kt diff --git a/idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch4.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch4.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch4.kt diff --git a/idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch5.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch5.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterComponentFunctionReturnTypeMismatch5.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/afterComponentFunctionReturnTypeMismatch5.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt b/idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt rename to idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt diff --git a/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToFunctionType.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToFunctionType.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToFunctionType.kt diff --git a/idea/testData/quickfix/typeMismatch/afterTypeMismatchInInitializer.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInInitializer.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterTypeMismatchInInitializer.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInInitializer.kt diff --git a/idea/testData/quickfix/typeMismatch/afterTypeMismatchInReturnStatement.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInReturnStatement.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/afterTypeMismatchInReturnStatement.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInReturnStatement.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToFunctionType.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToFunctionType.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeTypeMismatchInInitializer.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInInitializer.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeTypeMismatchInInitializer.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInInitializer.kt diff --git a/idea/testData/quickfix/typeMismatch/beforeTypeMismatchInReturnStatement.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInReturnStatement.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/beforeTypeMismatchInReturnStatement.kt rename to idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInReturnStatement.kt diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 0d9ee817a72..fb646cabc37 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1240,20 +1240,15 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } @TestMetadata("idea/testData/quickfix/typeMismatch") - @InnerTestClasses({TypeMismatch.Casts.class}) + @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) public static class TypeMismatch extends AbstractQuickFixTest { public void testAllFilesPresentInTypeMismatch() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); } - @TestMetadata("beforeChangeFunctionReturnTypeToFunctionType.kt") - public void testChangeFunctionReturnTypeToFunctionType() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToFunctionType.kt"); - } - - @TestMetadata("beforeChangeParameterTypeToFunctionType.kt") - public void testChangeParameterTypeToFunctionType() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeChangeParameterTypeToFunctionType.kt"); + @TestMetadata("beforeChangeFunctionLiteralParameterTypeToFunctionType.kt") + public void testChangeFunctionLiteralParameterTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt"); } @TestMetadata("beforeChangeReturnTypeWhenFunctionNameIsMissing.kt") @@ -1271,31 +1266,6 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/beforeCompareToTypeMismatch.kt"); } - @TestMetadata("beforeComponentFunctionReturnTypeMismatch1.kt") - public void testComponentFunctionReturnTypeMismatch1() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt"); - } - - @TestMetadata("beforeComponentFunctionReturnTypeMismatch2.kt") - public void testComponentFunctionReturnTypeMismatch2() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt"); - } - - @TestMetadata("beforeComponentFunctionReturnTypeMismatch3.kt") - public void testComponentFunctionReturnTypeMismatch3() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt"); - } - - @TestMetadata("beforeComponentFunctionReturnTypeMismatch4.kt") - public void testComponentFunctionReturnTypeMismatch4() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt"); - } - - @TestMetadata("beforeComponentFunctionReturnTypeMismatch5.kt") - public void testComponentFunctionReturnTypeMismatch5() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt"); - } - @TestMetadata("beforeExpectedParameterTypeMismatch.kt") public void testExpectedParameterTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/beforeExpectedParameterTypeMismatch.kt"); @@ -1321,16 +1291,6 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/beforeReturnTypeMismatch.kt"); } - @TestMetadata("beforeTypeMismatchInInitializer.kt") - public void testTypeMismatchInInitializer() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeTypeMismatchInInitializer.kt"); - } - - @TestMetadata("beforeTypeMismatchInReturnStatement.kt") - public void testTypeMismatchInReturnStatement() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/beforeTypeMismatchInReturnStatement.kt"); - } - @TestMetadata("idea/testData/quickfix/typeMismatch/casts") public static class Casts extends AbstractQuickFixTest { public void testAllFilesPresentInCasts() throws Exception { @@ -1384,10 +1344,68 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } + @TestMetadata("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch") + public static class ComponentFunctionReturnTypeMismatch extends AbstractQuickFixTest { + public void testAllFilesPresentInComponentFunctionReturnTypeMismatch() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); + } + + @TestMetadata("beforeComponentFunctionReturnTypeMismatch1.kt") + public void testComponentFunctionReturnTypeMismatch1() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch1.kt"); + } + + @TestMetadata("beforeComponentFunctionReturnTypeMismatch2.kt") + public void testComponentFunctionReturnTypeMismatch2() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch2.kt"); + } + + @TestMetadata("beforeComponentFunctionReturnTypeMismatch3.kt") + public void testComponentFunctionReturnTypeMismatch3() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch3.kt"); + } + + @TestMetadata("beforeComponentFunctionReturnTypeMismatch4.kt") + public void testComponentFunctionReturnTypeMismatch4() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch4.kt"); + } + + @TestMetadata("beforeComponentFunctionReturnTypeMismatch5.kt") + public void testComponentFunctionReturnTypeMismatch5() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch/beforeComponentFunctionReturnTypeMismatch5.kt"); + } + + } + + @TestMetadata("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression") + public static class TypeMismatchOnReturnedExpression extends AbstractQuickFixTest { + public void testAllFilesPresentInTypeMismatchOnReturnedExpression() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^before(\\w+)\\.kt$"), true); + } + + @TestMetadata("beforeChangeFunctionReturnTypeToFunctionType.kt") + public void testChangeFunctionReturnTypeToFunctionType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToFunctionType.kt"); + } + + @TestMetadata("beforeTypeMismatchInInitializer.kt") + public void testTypeMismatchInInitializer() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInInitializer.kt"); + } + + @TestMetadata("beforeTypeMismatchInReturnStatement.kt") + public void testTypeMismatchInReturnStatement() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInReturnStatement.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("TypeMismatch"); suite.addTestSuite(TypeMismatch.class); suite.addTestSuite(Casts.class); + suite.addTestSuite(ComponentFunctionReturnTypeMismatch.class); + suite.addTestSuite(TypeMismatchOnReturnedExpression.class); return suite; } } From 44fa32c617374627c6674f87322b2db88c887dd3 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 8 May 2013 18:34:13 +0200 Subject: [PATCH 52/92] ChangeFunctionParameterTypeFix for TYPE_MISMATCH error --- .../jetbrains/jet/plugin/JetBundle.properties | 1 + .../ChangeFunctionParameterTypeFix.java | 110 ++++++++++++++++++ .../jet/plugin/quickfix/QuickFixUtil.java | 62 +++++++++- .../jet/plugin/quickfix/QuickFixes.java | 4 +- .../afterChangeFunctionParameterType1.kt | 5 + .../afterChangeFunctionParameterType2.kt | 4 + .../afterChangeFunctionParameterType3.kt | 4 + .../beforeChangeFunctionParameterType1.kt | 5 + .../beforeChangeFunctionParameterType2.kt | 4 + .../beforeChangeFunctionParameterType3.kt | 4 + .../beforeChangeFunctionParameterType4.kt | 8 ++ .../beforeChangeFunctionParameterType5.kt | 5 + .../quickfix/QuickFixTestGenerated.java | 36 +++++- 13 files changed, 247 insertions(+), 5 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt create mode 100644 idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index c640470d94b..eb1f9fda628 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -62,6 +62,7 @@ change.no.name.function.return.type=Change function return type to ''{0}'' remove.function.return.type=Remove explicitly specified return type in ''{0}'' function remove.no.name.function.return.type=Remove explicitly specified function return type change.element.type=Change ''{0}'' type to ''{1}'' +change.function.parameter.type=Change parameter ''{0}'' type of function ''{1}'' to ''{2}'' change.type=Change type from ''{0}'' to ''{1}'' change.type.family=Change Type add.parameters.to.function=Add parameter{0} to function ''{1}'' diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java new file mode 100644 index 00000000000..0c7e797928f --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java @@ -0,0 +1,110 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +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 com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.NameUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; +import org.jetbrains.jet.renderer.DescriptorRenderer; + +public class ChangeFunctionParameterTypeFix extends JetIntentionAction { + private final String renderedType; + private final String containingFunctionName; + + public ChangeFunctionParameterTypeFix(@NotNull JetParameter element, @NotNull JetType type) { + super(element); + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); + JetFunction function = PsiTreeUtil.getParentOfType(element, JetFunction.class); + FqName functionFQName = function == null ? null : JetPsiUtil.getFQName(function); + containingFunctionName = functionFQName == null ? null : functionFQName.getFqName(); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + return super.isAvailable(project, editor, file) && containingFunctionName != null; + } + + @NotNull + @Override + public String getText() { + return JetBundle.message("change.function.parameter.type", element.getName(), containingFunctionName, renderedType); + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("change.type.family"); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { + JetTypeReference typeReference = element.getTypeReference(); + assert typeReference != null : "Parameter without type annotation cannot cause type mismatch"; + typeReference.replace(JetPsiFactory.createType(project, renderedType)); + } + + @NotNull + public static JetIntentionActionFactory createFactory() { + return new JetIntentionActionFactory() { + @Nullable + @Override + public IntentionAction createAction(Diagnostic diagnostic) { + // Change type of function parameter in case TYPE_MISMATCH is reported on expression passed as value argument of call + JetParameter correspondingParameter = null; + JetType type = null; + + BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) diagnostic.getPsiFile()).getBindingContext(); + JetFunctionLiteralExpression functionLiteralExpression = + QuickFixUtil.getParentElementOfType(diagnostic, JetFunctionLiteralExpression.class); + + if (functionLiteralExpression != null && diagnostic.getPsiElement() == functionLiteralExpression.getBodyExpression()) { + correspondingParameter = + QuickFixUtil.getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(functionLiteralExpression); + type = context.get(BindingContext.EXPRESSION_TYPE, functionLiteralExpression); + } + else { + JetValueArgument valueArgument = QuickFixUtil.getParentElementOfType(diagnostic, JetValueArgument.class); + if (valueArgument != null && valueArgument.getArgumentExpression() == diagnostic.getPsiElement()) { + correspondingParameter = QuickFixUtil.getFunctionParameterCorrespondingToValueArgumentPassedInCall(valueArgument); + type = context.get(BindingContext.EXPRESSION_TYPE, valueArgument.getArgumentExpression()); + } + } + if (correspondingParameter != null && type != null) { + return new ChangeFunctionParameterTypeFix(correspondingParameter, type); + } + return null; + } + }; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index a1d9aa40425..7c3f2971576 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -26,10 +26,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.psi.JetDeclaration; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetNamedDeclaration; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.types.DeferredType; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; @@ -93,4 +93,60 @@ public class QuickFixUtil { public static boolean canModifyElement(@NotNull PsiElement element) { return element.isWritable() && !BuiltInsReferenceResolver.isFromBuiltIns(element); } + + @Nullable + public static JetParameterList getParameterListOfCalledFunction(@NotNull JetCallExpression callExpression) { + BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) callExpression.getContainingFile()).getBindingContext(); + ResolvedCall resolvedCall = context.get(BindingContext.RESOLVED_CALL, callExpression.getCalleeExpression()); + if (resolvedCall == null) return null; + PsiElement functionDeclaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); + if (functionDeclaration instanceof JetFunction) { + return ((JetFunction) functionDeclaration).getValueParameterList(); + } + return null; + } + + @Nullable + public static JetParameter getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(@NotNull JetFunctionLiteralExpression functionLiteralExpression) { + if (!(functionLiteralExpression.getParent() instanceof JetCallExpression)) { + return null; + } + JetCallExpression callExpression = (JetCallExpression) functionLiteralExpression.getParent(); + JetParameterList parameterList = getParameterListOfCalledFunction(callExpression); + if (parameterList == null) return null; + return parameterList.getParameters().get(parameterList.getParameters().size() - 1); + } + + @Nullable + public static JetParameter getFunctionParameterCorrespondingToValueArgumentPassedInCall(@NotNull JetValueArgument valueArgument) { + if (!(valueArgument.getParent() instanceof JetValueArgumentList)) { + return null; + } + JetValueArgumentList valueArgumentList = (JetValueArgumentList) valueArgument.getParent(); + if (!(valueArgumentList.getParent() instanceof JetCallExpression)) { + return null; + } + JetCallExpression callExpression = (JetCallExpression) valueArgumentList.getParent(); + JetParameterList parameterList = getParameterListOfCalledFunction(callExpression); + if (parameterList == null) return null; + int position = valueArgumentList.getArguments().indexOf(valueArgument); + if (position == -1) return null; + + if (valueArgument.isNamed()) { + JetValueArgumentName valueArgumentName = valueArgument.getArgumentName(); + JetSimpleNameExpression referenceExpression = valueArgumentName == null ? null : valueArgumentName.getReferenceExpression(); + String valueArgumentNameAsString = referenceExpression == null ? null : referenceExpression.getReferencedName(); + if (valueArgumentNameAsString == null) return null; + + for (JetParameter parameter: parameterList.getParameters()) { + if (valueArgumentNameAsString.equals(parameter.getName())) { + return parameter; + } + } + return null; + } + else { + return parameterList.getParameters().get(position); + } + } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index be8f7fb5b30..c1fd41dab2e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -235,7 +235,9 @@ public class QuickFixes { factories.put(EXPECTED_PARAMETER_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedParameterTypeMismatch()); factories.put(EXPECTED_RETURN_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedReturnTypeMismatch()); - + + factories.put(TYPE_MISMATCH, ChangeFunctionParameterTypeFix.createFactory()); + factories.put(AUTOCAST_IMPOSSIBLE, CastExpressionFix.createFactoryForAutoCastImpossible()); factories.put(TYPE_MISMATCH, CastExpressionFix.createFactoryForTypeMismatch()); diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt new file mode 100644 index 00000000000..b253e8b1782 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt @@ -0,0 +1,5 @@ +// "Change parameter 'x' type of function 'bar.foo' to '(String) -> Int'" "true" +package bar +fun foo(w: Int = 0, x: (String) -> Int, y: Int = 0, z: (Int) -> Int = {42}) { + foo(1, {(a: String) -> 42}, 1) +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt new file mode 100644 index 00000000000..c1b3343642c --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt @@ -0,0 +1,4 @@ +// "Change parameter 'y' type of function 'foo' to 'String'" "true" +fun foo(v: Int, w: Int = 0, x: Int = 0, y: String, z: (Int) -> Int = {42}) { + foo(0, 1, y = "") +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt new file mode 100644 index 00000000000..30b490ba5ed --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt @@ -0,0 +1,4 @@ +// "Change parameter 'z' type of function 'foo' to '(Int) -> Unit'" "true" +fun foo(w: Int = 0, x: Int, y: Int = 0, z: (Int) -> Unit) { + foo(0, 1) {} +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt new file mode 100644 index 00000000000..deb5313f041 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt @@ -0,0 +1,5 @@ +// "Change parameter 'x' type of function 'bar.foo' to '(String) -> Int'" "true" +package bar +fun foo(w: Int = 0, x: Int, y: Int = 0, z: (Int) -> Int = {42}) { + foo(1, {(a: String) -> 42}, 1) +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt new file mode 100644 index 00000000000..c5e45b514be --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt @@ -0,0 +1,4 @@ +// "Change parameter 'y' type of function 'foo' to 'String'" "true" +fun foo(v: Int, w: Int = 0, x: Int = 0, y: Int, z: (Int) -> Int = {42}) { + foo(0, 1, y = "") +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt new file mode 100644 index 00000000000..9d5f48d961d --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt @@ -0,0 +1,4 @@ +// "Change parameter 'z' type of function 'foo' to '(Int) -> Unit'" "true" +fun foo(w: Int = 0, x: Int, y: Int = 0, z: (Int) -> String) { + foo(0, 1) {} +} diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt new file mode 100644 index 00000000000..a4c9f02baaf --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt @@ -0,0 +1,8 @@ +// "Change parameter 'z' type of function 'foo' to '(Int) -> String'" "false" +// ERROR: Type mismatch.
Required:jet.Int
Found:jet.String
+fun foo(y: Int = 0, z: (Int) -> String = {""}) { + foo { + "": Int + "" + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt new file mode 100644 index 00000000000..80f37c15a85 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt @@ -0,0 +1,5 @@ +// "Change parameter 'y' type of function 'foo' to 'Int'" "false" +// ERROR: Type mismatch.
Required:jet.Int
Found:jet.String
+fun foo(y: Int = 0, z: (Int) -> String = {""}) { + foo("": Int) +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index fb646cabc37..20ca2288240 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1240,7 +1240,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } @TestMetadata("idea/testData/quickfix/typeMismatch") - @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) + @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.FunctionParameterTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) public static class TypeMismatch extends AbstractQuickFixTest { public void testAllFilesPresentInTypeMismatch() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); @@ -1377,6 +1377,39 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } + @TestMetadata("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch") + public static class FunctionParameterTypeMismatch extends AbstractQuickFixTest { + public void testAllFilesPresentInFunctionParameterTypeMismatch() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); + } + + @TestMetadata("beforeChangeFunctionParameterType1.kt") + public void testChangeFunctionParameterType1() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt"); + } + + @TestMetadata("beforeChangeFunctionParameterType2.kt") + public void testChangeFunctionParameterType2() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt"); + } + + @TestMetadata("beforeChangeFunctionParameterType3.kt") + public void testChangeFunctionParameterType3() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt"); + } + + @TestMetadata("beforeChangeFunctionParameterType4.kt") + public void testChangeFunctionParameterType4() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt"); + } + + @TestMetadata("beforeChangeFunctionParameterType5.kt") + public void testChangeFunctionParameterType5() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt"); + } + + } + @TestMetadata("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression") public static class TypeMismatchOnReturnedExpression extends AbstractQuickFixTest { public void testAllFilesPresentInTypeMismatchOnReturnedExpression() throws Exception { @@ -1405,6 +1438,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { suite.addTestSuite(TypeMismatch.class); suite.addTestSuite(Casts.class); suite.addTestSuite(ComponentFunctionReturnTypeMismatch.class); + suite.addTestSuite(FunctionParameterTypeMismatch.class); suite.addTestSuite(TypeMismatchOnReturnedExpression.class); return suite; } From 9b90ee2e8006ab376b296fa6bdb315ba3744ed72 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 8 May 2013 18:55:31 +0200 Subject: [PATCH 53/92] ChangeFunctionLiteralReturnTypeFix for EXPECTED/ASSIGNMENT_TYPE_MISMATCH errors --- .../jetbrains/jet/plugin/JetBundle.properties | 1 + .../ChangeFunctionLiteralReturnTypeFix.java | 140 ++++++++++++++++++ .../jet/plugin/quickfix/QuickFixUtil.java | 25 ++++ .../jet/plugin/quickfix/QuickFixes.java | 4 + .../afterAssignmentTypeMismatch.kt | 7 + .../afterExpectedTypeMismatch.kt | 7 + .../beforeAssignmentTypeMismatch.kt | 7 + .../beforeExpectedTypeMismatch.kt | 7 + .../quickfix/QuickFixTestGenerated.java | 10 ++ 9 files changed, 208 insertions(+) create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterAssignmentTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterExpectedTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index eb1f9fda628..6f7ebde6deb 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -59,6 +59,7 @@ add.semicolon.after.invocation=Add semicolon after invocation of ''{0}'' add.semicolon.family=Add Semicolon change.function.return.type=Change ''{0}'' function return type to ''{1}'' change.no.name.function.return.type=Change function return type to ''{0}'' +change.function.literal.return.type=Change function literal return type to ''{0}'' remove.function.return.type=Remove explicitly specified return type in ''{0}'' function remove.no.name.function.return.type=Remove explicitly specified function return type change.element.type=Change ''{0}'' type to ''{1}'' diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java new file mode 100644 index 00000000000..c93d084532e --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java @@ -0,0 +1,140 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +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.PsiFile; +import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.util.IncorrectOperationException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; +import org.jetbrains.jet.renderer.DescriptorRenderer; + +import java.util.LinkedList; +import java.util.List; + +public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction { + private final String renderedType; + private final JetTypeReference functionLiteralReturnTypeRef; + private IntentionAction appropriateQuickFix = null; + + public ChangeFunctionLiteralReturnTypeFix(@NotNull JetFunctionLiteralExpression element, @NotNull JetType type) { + super(element); + renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); + functionLiteralReturnTypeRef = element.getFunctionLiteral().getReturnTypeRef(); + + BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) element.getContainingFile()).getBindingContext(); + JetType functionLiteralType = context.get(BindingContext.EXPRESSION_TYPE, element); + assert functionLiteralType != null : "Type of function literal not available in binding context"; + + ClassDescriptor functionClass = KotlinBuiltIns.getInstance().getFunction(functionLiteralType.getArguments().size() - 1); + List functionClassTypeParameters = new LinkedList(); + for (TypeProjection typeProjection: functionLiteralType.getArguments()) { + functionClassTypeParameters.add(typeProjection.getType()); + } + // Replacing return type: + functionClassTypeParameters.remove(functionClassTypeParameters.size() - 1); + functionClassTypeParameters.add(type); + JetType eventualFunctionLiteralType = TypeUtils.substituteParameters(functionClass, functionClassTypeParameters); + + JetProperty correspondingProperty = PsiTreeUtil.getParentOfType(element, JetProperty.class); + if (correspondingProperty != null && QuickFixUtil.canEvaluateTo(correspondingProperty.getInitializer(), element)) { + JetTypeReference correspondingPropertyTypeRef = correspondingProperty.getTypeRef(); + JetType propertyType = context.get(BindingContext.TYPE, correspondingPropertyTypeRef); + if (propertyType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(eventualFunctionLiteralType, propertyType)) { + appropriateQuickFix = new ChangeVariableTypeFix(correspondingProperty, eventualFunctionLiteralType); + } + return; + } + + JetParameter correspondingParameter = QuickFixUtil.getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(element); + if (correspondingParameter != null) { + JetTypeReference correspondingParameterTypeRef = correspondingParameter.getTypeReference(); + JetType parameterType = context.get(BindingContext.TYPE, correspondingParameterTypeRef); + if (parameterType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(eventualFunctionLiteralType, parameterType)) { + appropriateQuickFix = new ChangeFunctionParameterTypeFix(correspondingParameter, eventualFunctionLiteralType); + } + return; + } + + JetFunction parentFunction = PsiTreeUtil.getParentOfType(element, JetFunction.class, true); + if (parentFunction != null && QuickFixUtil.canFunctionReturnExpression(parentFunction, element)) { + JetTypeReference parentFunctionReturnTypeRef = parentFunction.getReturnTypeRef(); + JetType parentFunctionReturnType = context.get(BindingContext.TYPE, parentFunctionReturnTypeRef); + if (parentFunctionReturnType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(eventualFunctionLiteralType, parentFunctionReturnType)) { + appropriateQuickFix = new ChangeFunctionReturnTypeFix(parentFunction, eventualFunctionLiteralType); + } + } + } + + @NotNull + @Override + public String getText() { + if (appropriateQuickFix != null) { + return appropriateQuickFix.getText(); + } + return JetBundle.message("change.function.literal.return.type", renderedType); + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("change.type.family"); + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { + return super.isAvailable(project, editor, file) && + (functionLiteralReturnTypeRef != null || (appropriateQuickFix != null && appropriateQuickFix.isAvailable(project, editor, file))); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { + if (functionLiteralReturnTypeRef != null) { + functionLiteralReturnTypeRef.replace(JetPsiFactory.createType(project, renderedType)); + } + if (appropriateQuickFix != null && appropriateQuickFix.isAvailable(project, editor, file)) { + appropriateQuickFix.invoke(project, editor, file); + } + } + + @NotNull + public static JetIntentionActionFactory createFactoryForExpectedOrAssignmentTypeMismatch() { + return new JetIntentionActionFactory() { + @Nullable + @Override + public IntentionAction createAction(Diagnostic diagnostic) { + JetFunctionLiteralExpression functionLiteralExpression = QuickFixUtil.getParentElementOfType(diagnostic, JetFunctionLiteralExpression.class); + assert functionLiteralExpression != null : "ASSIGNMENT/EXPECTED_TYPE_MISMATCH reported outside any function literal"; + return new ChangeFunctionLiteralReturnTypeFix(functionLiteralExpression, KotlinBuiltIns.getInstance().getUnitType()); + } + }; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index 7c3f2971576..beb270a8724 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -149,4 +149,29 @@ public class QuickFixUtil { return parameterList.getParameters().get(position); } } + + private static boolean equalOrLastInThenOrElse(JetExpression thenOrElse, JetExpression expression) { + if (thenOrElse == expression) return true; + return thenOrElse instanceof JetBlockExpression && expression.getParent() == thenOrElse && + PsiTreeUtil.getNextSiblingOfType(expression, JetExpression.class) == null; + } + + public static boolean canEvaluateTo(JetExpression parent, JetExpression child) { + if (parent == null || child == null) { + return false; + } + while (parent != child) { + if (child.getParent() instanceof JetParenthesizedExpression) { + child = (JetExpression) child.getParent(); + continue; + } + JetIfExpression jetIfExpression = PsiTreeUtil.getParentOfType(child, JetIfExpression.class, true); + if (jetIfExpression == null) return false; + if (!equalOrLastInThenOrElse(jetIfExpression.getThen(), child) && !equalOrLastInThenOrElse(jetIfExpression.getElse(), child)) { + return false; + } + child = jetIfExpression; + } + return true; + } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index c1fd41dab2e..a6b9c110a51 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -236,6 +236,10 @@ public class QuickFixes { factories.put(EXPECTED_PARAMETER_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedParameterTypeMismatch()); factories.put(EXPECTED_RETURN_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedReturnTypeMismatch()); + JetIntentionActionFactory changeFunctionLiteralReturnTypeFix = ChangeFunctionLiteralReturnTypeFix.createFactoryForExpectedOrAssignmentTypeMismatch(); + factories.put(EXPECTED_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); + factories.put(ASSIGNMENT_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); + factories.put(TYPE_MISMATCH, ChangeFunctionParameterTypeFix.createFactory()); factories.put(AUTOCAST_IMPOSSIBLE, CastExpressionFix.createFactoryForAutoCastImpossible()); diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterAssignmentTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterAssignmentTypeMismatch.kt new file mode 100644 index 00000000000..ac73a6453e9 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterAssignmentTypeMismatch.kt @@ -0,0 +1,7 @@ +// "Change 'f' type to '() -> Unit'" "true" +fun foo() { + val f: () -> Unit = { + var x = 1 + x += 21 + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterExpectedTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterExpectedTypeMismatch.kt new file mode 100644 index 00000000000..d51e2648772 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterExpectedTypeMismatch.kt @@ -0,0 +1,7 @@ +// "Change 'bar' type to '(() -> Long) -> Unit'" "true" +fun foo() { + val bar: (() -> Long) -> Unit = { + (f: () -> Long): Unit -> + var x = 5 + } +} diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt new file mode 100644 index 00000000000..ad45d53e8c7 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt @@ -0,0 +1,7 @@ +// "Change 'f' type to '() -> Unit'" "true" +fun foo() { + val f: () -> Int = { + var x = 1 + x += 21 + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt new file mode 100644 index 00000000000..379a397ab85 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt @@ -0,0 +1,7 @@ +// "Change 'bar' type to '(() -> Long) -> Unit'" "true" +fun foo() { + val bar: () -> Double = { + (f: () -> Long): String -> + var x = 5 + } +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 20ca2288240..810c38bc41d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1416,11 +1416,21 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^before(\\w+)\\.kt$"), true); } + @TestMetadata("beforeAssignmentTypeMismatch.kt") + public void testAssignmentTypeMismatch() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt"); + } + @TestMetadata("beforeChangeFunctionReturnTypeToFunctionType.kt") public void testChangeFunctionReturnTypeToFunctionType() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToFunctionType.kt"); } + @TestMetadata("beforeExpectedTypeMismatch.kt") + public void testExpectedTypeMismatch() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt"); + } + @TestMetadata("beforeTypeMismatchInInitializer.kt") public void testTypeMismatchInInitializer() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInInitializer.kt"); From 0144ad06706530c6d972ed15d3dfcff5d25cab65 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 8 May 2013 23:18:36 +0200 Subject: [PATCH 54/92] Enable intention actions factories to return multiple quickfixes --- .../jet/plugin/highlighter/JetPsiChecker.java | 17 +++---- .../plugin/quickfix/AddFunctionBodyFix.java | 4 +- .../quickfix/AddFunctionToSupertypeFix.java | 4 +- .../jet/plugin/quickfix/AddModifierFix.java | 6 +-- .../plugin/quickfix/AddNameToArgumentFix.java | 4 +- .../AddOpenModifierToClassDeclarationFix.java | 4 +- .../AddSemicolonAfterFunctionCallFix.java | 4 +- .../quickfix/AddStarProjectionsFix.java | 8 ++-- .../plugin/quickfix/AddWhenElseBranchFix.java | 4 +- .../jet/plugin/quickfix/AutoImportFix.java | 4 +- .../plugin/quickfix/CastExpressionFix.java | 8 ++-- .../quickfix/ChangeAccessorTypeFix.java | 4 +- .../ChangeFunctionLiteralReturnTypeFix.java | 4 +- .../ChangeFunctionParameterTypeFix.java | 9 +--- .../quickfix/ChangeFunctionReturnTypeFix.java | 24 +++++----- .../quickfix/ChangeFunctionSignatureFix.java | 12 ++--- .../ChangeMemberFunctionSignatureFix.java | 4 +- .../quickfix/ChangeToBackingFieldFix.java | 4 +- .../ChangeToConstructorInvocationFix.java | 4 +- .../ChangeToFunctionInvocationFix.java | 4 +- .../quickfix/ChangeToPropertyNameFix.java | 4 +- .../quickfix/ChangeToStarProjectionFix.java | 4 +- .../jet/plugin/quickfix/ChangeTypeFix.java | 8 ++-- .../quickfix/ChangeVariableTypeFix.java | 8 ++-- .../quickfix/ChangeVisibilityModifierFix.java | 4 +- ...y.java => JetIntentionActionsFactory.java} | 9 ++-- .../JetSingleIntentionActionFactory.java | 42 +++++++++++++++++ .../MakeClassAnAnnotationClassFix.java | 4 +- .../quickfix/MakeOverriddenMemberOpenFix.java | 4 +- .../quickfix/MapPlatformClassToKotlinFix.java | 4 +- .../quickfix/MigrateSureInProjectFix.java | 4 +- .../quickfix/MoveWhenElseBranchFix.java | 4 +- .../jet/plugin/quickfix/QuickFixes.java | 46 +++++++++---------- .../quickfix/RemoveFunctionBodyFix.java | 4 +- .../plugin/quickfix/RemoveModifierFix.java | 20 ++++---- .../plugin/quickfix/RemoveNullableFix.java | 4 +- .../quickfix/RemovePartsFromPropertyFix.java | 4 +- .../quickfix/RemovePsiElementSimpleFix.java | 16 +++---- .../RemoveRightPartOfBinaryExpressionFix.java | 8 ++-- .../plugin/quickfix/RemoveSupertypeFix.java | 4 +- ...meParameterToMatchOverriddenMethodFix.java | 4 +- .../plugin/quickfix/ReplaceInfixCallFix.java | 4 +- ...ReplaceOperationInBinaryExpressionFix.java | 5 +- 43 files changed, 194 insertions(+), 160 deletions(-) rename idea/src/org/jetbrains/jet/plugin/quickfix/{JetIntentionActionFactory.java => JetIntentionActionsFactory.java} (80%) create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/JetSingleIntentionActionFactory.java diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java index 21d32d41fa7..21b4a2a6729 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java @@ -43,9 +43,8 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; -import org.jetbrains.jet.plugin.quickfix.JetIntentionActionFactory; +import org.jetbrains.jet.plugin.quickfix.JetIntentionActionsFactory; import org.jetbrains.jet.plugin.quickfix.QuickFixes; -import org.jetbrains.jet.utils.ExceptionUtils; import java.util.Collection; import java.util.List; @@ -217,14 +216,12 @@ public class JetPsiChecker implements Annotator { return null; } - Collection intentionActionFactories = QuickFixes.getActionFactories(diagnostic.getFactory()); - for (JetIntentionActionFactory intentionActionFactory : intentionActionFactories) { - IntentionAction action = null; - if (intentionActionFactory != null) { - action = intentionActionFactory.createAction(diagnostic); - } - if (action != null) { - annotation.registerFix(action); + Collection intentionActionsFactories = QuickFixes.getActionsFactories(diagnostic.getFactory()); + for (JetIntentionActionsFactory intentionActionsFactory : intentionActionsFactories) { + if (intentionActionsFactory != null) { + for (IntentionAction action: intentionActionsFactory.createActions(diagnostic)) { + annotation.registerFix(action); + } } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java index 2654f228e78..b0819791d25 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionBodyFix.java @@ -67,8 +67,8 @@ public class AddFunctionBodyFix extends JetIntentionAction { element.replace(newElement); } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java index 05844b5f937..f565679cb6d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java @@ -158,8 +158,8 @@ public class AddFunctionToSupertypeFix extends JetHintAction { return new JetAddFunctionToClassifierAction(project, editor, bindingContext, functionsToAdd); } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetIntentionActionsFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java index 162dc6b7aa3..d3bdd9b985e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddModifierFix.java @@ -164,8 +164,8 @@ public class AddModifierFix extends JetIntentionAction { return true; } - public static JetIntentionActionFactory createFactory(final JetKeywordToken modifier, final Class modifierOwnerClass) { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory(final JetKeywordToken modifier, final Class modifierOwnerClass) { + return new JetSingleIntentionActionFactory() { @Override public IntentionAction createAction(Diagnostic diagnostic) { JetModifierListOwner modifierListOwner = QuickFixUtil.getParentElementOfType(diagnostic, modifierOwnerClass); @@ -175,7 +175,7 @@ public class AddModifierFix extends JetIntentionAction { }; } - public static JetIntentionActionFactory createFactory(JetKeywordToken modifier) { + public static JetSingleIntentionActionFactory createFactory(JetKeywordToken modifier) { return createFactory(modifier, JetModifierListOwner.class); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java index cc53c6ad0e3..93c03343de2 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java @@ -183,8 +183,8 @@ public class AddNameToArgumentFix extends JetIntentionAction { return JetBundle.message("add.name.to.argument.family"); } @NotNull - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetIntentionActionsFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddOpenModifierToClassDeclarationFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddOpenModifierToClassDeclarationFix.java index 8fa3b39a8c6..13509245a17 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddOpenModifierToClassDeclarationFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddOpenModifierToClassDeclarationFix.java @@ -81,8 +81,8 @@ public class AddOpenModifierToClassDeclarationFix extends JetIntentionAction editor.getCaretModel().moveToOffset(textRange.getStartOffset() + indexOfOpenBrace + 1); } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java index c4cdd8d9533..68b66bfa623 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.java @@ -289,8 +289,8 @@ public class AutoImportFix extends JetHintAction implem } @Nullable - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(@NotNull Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java index 9d96a551817..6cbf68bf8a9 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java @@ -81,8 +81,8 @@ public class CastExpressionFix extends JetIntentionAction { } @NotNull - public static JetIntentionActionFactory createFactoryForAutoCastImpossible() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactoryForAutoCastImpossible() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { @@ -96,8 +96,8 @@ public class CastExpressionFix extends JetIntentionAction { } @NotNull - public static JetIntentionActionFactory createFactoryForTypeMismatch() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactoryForTypeMismatch() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java index 6eef4a97ffe..59dee5775e8 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeAccessorTypeFix.java @@ -83,8 +83,8 @@ public class ChangeAccessorTypeFix extends JetIntentionAction createAction(Diagnostic diagnostic) { JetPropertyAccessor accessor = QuickFixUtil.getParentElementOfType(diagnostic, JetPropertyAccessor.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java index c93d084532e..b257b99cfdc 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java @@ -126,8 +126,8 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction createAction(Diagnostic diagnostic) { JetSimpleNameExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetSimpleNameExpression.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java index 7890d0a49da..3cb0532bf48 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java @@ -84,8 +84,8 @@ public class ChangeToConstructorInvocationFix extends JetIntentionAction createAction(Diagnostic diagnostic) { if (diagnostic.getPsiElement() instanceof JetDelegatorToSuperClass) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java index acbdc338f17..b96a01b3155 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToFunctionInvocationFix.java @@ -50,8 +50,8 @@ public class ChangeToFunctionInvocationFix extends JetIntentionAction createAction(Diagnostic diagnostic) { if (diagnostic.getPsiElement() instanceof JetExpression) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToPropertyNameFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToPropertyNameFix.java index 96ecda49d7e..9d832492d35 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToPropertyNameFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToPropertyNameFix.java @@ -58,8 +58,8 @@ public class ChangeToPropertyNameFix extends JetIntentionAction createAction(Diagnostic diagnostic) { JetSimpleNameExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetSimpleNameExpression.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToStarProjectionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToStarProjectionFix.java index 18c050c42d3..ac083e375bd 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToStarProjectionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToStarProjectionFix.java @@ -54,8 +54,8 @@ public class ChangeToStarProjectionFix extends JetIntentionAction { } @NotNull - public static JetIntentionActionFactory createFactoryForExpectedParameterTypeMismatch() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactoryForExpectedParameterTypeMismatch() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { @@ -75,8 +75,8 @@ public class ChangeTypeFix extends JetIntentionAction { } @NotNull - public static JetIntentionActionFactory createFactoryForExpectedReturnTypeMismatch() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactoryForExpectedReturnTypeMismatch() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index 3236e846711..c70d024f7a6 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -67,8 +67,8 @@ public class ChangeVariableTypeFix extends JetIntentionAction createAction(Diagnostic diagnostic) { PsiElement element = diagnostic.getPsiElement(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionsFactory.java similarity index 80% rename from idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java rename to idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionsFactory.java index 3301507e6ac..953acf3469b 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionActionsFactory.java @@ -17,12 +17,13 @@ package org.jetbrains.jet.plugin.quickfix; import com.intellij.codeInsight.intention.IntentionAction; -import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -public interface JetIntentionActionFactory { +import java.util.List; - @Nullable - IntentionAction createAction(Diagnostic diagnostic); +public interface JetIntentionActionsFactory { + @NotNull + List createActions(Diagnostic diagnostic); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/JetSingleIntentionActionFactory.java b/idea/src/org/jetbrains/jet/plugin/quickfix/JetSingleIntentionActionFactory.java new file mode 100644 index 00000000000..1ecbd890a63 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/JetSingleIntentionActionFactory.java @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.quickfix; + +import com.intellij.codeInsight.intention.IntentionAction; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; + +import java.util.LinkedList; +import java.util.List; + +public abstract class JetSingleIntentionActionFactory implements JetIntentionActionsFactory { + + @Nullable + public abstract IntentionAction createAction(Diagnostic diagnostic); + + @NotNull + @Override + public final List createActions(Diagnostic diagnostic) { + List intentionActionList = new LinkedList(); + IntentionAction intentionAction = createAction(diagnostic); + if (intentionAction != null) { + intentionActionList.add(intentionAction); + } + return intentionActionList; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MakeClassAnAnnotationClassFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MakeClassAnAnnotationClassFix.java index 4f5191179a3..6f2712cc75d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MakeClassAnAnnotationClassFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MakeClassAnAnnotationClassFix.java @@ -90,8 +90,8 @@ public class MakeClassAnAnnotationClassFix extends JetIntentionAction { } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MoveWhenElseBranchFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MoveWhenElseBranchFix.java index 132d8989c9d..95e503a6eab 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MoveWhenElseBranchFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MoveWhenElseBranchFix.java @@ -78,8 +78,8 @@ public class MoveWhenElseBranchFix extends JetIntentionAction editor.getCaretModel().moveToOffset(insertedWhenEntry.getTextOffset() + cursorOffset); } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index a6b9c110a51..7a4ce23f253 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -30,10 +30,10 @@ import static org.jetbrains.jet.lexer.JetTokens.*; public class QuickFixes { - private static final Multimap factories = HashMultimap.create(); + private static final Multimap factories = HashMultimap.create(); private static final Multimap actions = HashMultimap.create(); - public static Collection getActionFactories(AbstractDiagnosticFactory diagnosticFactory) { + public static Collection getActionsFactories(AbstractDiagnosticFactory diagnosticFactory) { return factories.get(diagnosticFactory); } @@ -44,12 +44,12 @@ public class QuickFixes { private QuickFixes() {} static { - JetIntentionActionFactory removeAbstractModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD); - JetIntentionActionFactory addAbstractModifierFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD); + JetSingleIntentionActionFactory removeAbstractModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD); + JetSingleIntentionActionFactory addAbstractModifierFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD); factories.put(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, removeAbstractModifierFactory); - JetIntentionActionFactory removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory(); + JetSingleIntentionActionFactory removePartsFromPropertyFactory = RemovePartsFromPropertyFix.createFactory(); factories.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, removeAbstractModifierFactory); factories.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, removePartsFromPropertyFactory); @@ -63,13 +63,13 @@ public class QuickFixes { factories.put(MUST_BE_INITIALIZED_OR_BE_ABSTRACT, addAbstractModifierFactory); - JetIntentionActionFactory removeFinalModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(FINAL_KEYWORD); + JetSingleIntentionActionFactory removeFinalModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(FINAL_KEYWORD); - JetIntentionActionFactory addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, JetClass.class); + JetSingleIntentionActionFactory addAbstractToClassFactory = AddModifierFix.createFactory(ABSTRACT_KEYWORD, JetClass.class); factories.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory); factories.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory); - JetIntentionActionFactory removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory(); + JetSingleIntentionActionFactory removeFunctionBodyFactory = RemoveFunctionBodyFix.createFactory(); factories.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, removeAbstractModifierFactory); factories.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, addAbstractToClassFactory); @@ -79,7 +79,7 @@ public class QuickFixes { factories.put(FINAL_PROPERTY_IN_TRAIT, removeFinalModifierFactory); factories.put(FINAL_FUNCTION_WITH_NO_BODY, removeFinalModifierFactory); - JetIntentionActionFactory addFunctionBodyFactory = AddFunctionBodyFix.createFactory(); + JetSingleIntentionActionFactory addFunctionBodyFactory = AddFunctionBodyFix.createFactory(); factories.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addAbstractModifierFactory); factories.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, addFunctionBodyFactory); @@ -97,13 +97,13 @@ public class QuickFixes { factories.put(USELESS_CAST_STATIC_ASSERT_IS_FINE, ReplaceOperationInBinaryExpressionFix.createChangeCastToStaticAssertFactory()); factories.put(USELESS_CAST, RemoveRightPartOfBinaryExpressionFix.createRemoveCastFactory()); - JetIntentionActionFactory changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory(); + JetSingleIntentionActionFactory changeAccessorTypeFactory = ChangeAccessorTypeFix.createFactory(); factories.put(WRONG_SETTER_PARAMETER_TYPE, changeAccessorTypeFactory); factories.put(WRONG_GETTER_RETURN_TYPE, changeAccessorTypeFactory); factories.put(USELESS_ELVIS, RemoveRightPartOfBinaryExpressionFix.createRemoveElvisOperatorFactory()); - JetIntentionActionFactory removeRedundantModifierFactory = RemoveModifierFix.createRemoveModifierFactory(true); + JetSingleIntentionActionFactory removeRedundantModifierFactory = RemoveModifierFix.createRemoveModifierFactory(true); factories.put(REDUNDANT_MODIFIER, removeRedundantModifierFactory); factories.put(ABSTRACT_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(ABSTRACT_KEYWORD, true)); factories.put(OPEN_MODIFIER_IN_TRAIT, RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD, true)); @@ -112,28 +112,28 @@ public class QuickFixes { factories.put(INCOMPATIBLE_MODIFIERS, RemoveModifierFix.createRemoveModifierFactory(false)); factories.put(VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY, RemoveModifierFix.createRemoveVarianceFactory()); - JetIntentionActionFactory removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD); + JetSingleIntentionActionFactory removeOpenModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(OPEN_KEYWORD); factories.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, AddModifierFix.createFactory(OPEN_KEYWORD, JetClass.class)); factories.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, removeOpenModifierFactory); - JetIntentionActionFactory removeModifierFactory = RemoveModifierFix.createRemoveModifierFactory(); + JetSingleIntentionActionFactory removeModifierFactory = RemoveModifierFix.createRemoveModifierFactory(); factories.put(GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, removeModifierFactory); factories.put(REDUNDANT_MODIFIER_IN_GETTER, removeRedundantModifierFactory); factories.put(ILLEGAL_MODIFIER, removeModifierFactory); - JetIntentionActionFactory changeToBackingFieldFactory = ChangeToBackingFieldFix.createFactory(); + JetSingleIntentionActionFactory changeToBackingFieldFactory = ChangeToBackingFieldFix.createFactory(); factories.put(INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER, changeToBackingFieldFactory); factories.put(INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER, changeToBackingFieldFactory); - JetIntentionActionFactory changeToPropertyNameFactory = ChangeToPropertyNameFix.createFactory(); + JetSingleIntentionActionFactory changeToPropertyNameFactory = ChangeToPropertyNameFix.createFactory(); factories.put(NO_BACKING_FIELD_ABSTRACT_PROPERTY, changeToPropertyNameFactory); factories.put(NO_BACKING_FIELD_CUSTOM_ACCESSORS, changeToPropertyNameFactory); factories.put(INACCESSIBLE_BACKING_FIELD, changeToPropertyNameFactory); - JetIntentionActionFactory unresolvedReferenceFactory = AutoImportFix.createFactory(); + JetSingleIntentionActionFactory unresolvedReferenceFactory = AutoImportFix.createFactory(); factories.put(UNRESOLVED_REFERENCE, unresolvedReferenceFactory); - JetIntentionActionFactory removeImportFixFactory = RemovePsiElementSimpleFix.createRemoveImportFactory(); + JetSingleIntentionActionFactory removeImportFixFactory = RemovePsiElementSimpleFix.createRemoveImportFactory(); factories.put(USELESS_SIMPLE_IMPORT, removeImportFixFactory); factories.put(USELESS_HIDDEN_IMPORT, removeImportFixFactory); @@ -173,7 +173,7 @@ public class QuickFixes { actions.put(UNNECESSARY_NOT_NULL_ASSERTION, ExclExclCallFix.removeExclExclCall()); factories.put(UNSAFE_INFIX_CALL, ReplaceInfixCallFix.createFactory()); - JetIntentionActionFactory removeProtectedModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(PROTECTED_KEYWORD); + JetSingleIntentionActionFactory removeProtectedModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(PROTECTED_KEYWORD); factories.put(PACKAGE_MEMBER_CANNOT_BE_PROTECTED, removeProtectedModifierFactory); actions.put(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, new SpecifyTypeExplicitlyFix()); @@ -187,13 +187,13 @@ public class QuickFixes { factories.put(TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER, RemovePsiElementSimpleFix.createRemoveTypeArgumentsFactory()); - JetIntentionActionFactory changeToStarProjectionFactory = ChangeToStarProjectionFix.createFactory(); + JetSingleIntentionActionFactory changeToStarProjectionFactory = ChangeToStarProjectionFix.createFactory(); factories.put(UNCHECKED_CAST, changeToStarProjectionFactory); factories.put(CANNOT_CHECK_FOR_ERASED, changeToStarProjectionFactory); factories.put(INACCESSIBLE_OUTER_CLASS_EXPRESSION, AddModifierFix.createFactory(INNER_KEYWORD, JetClass.class)); - JetIntentionActionFactory addOpenModifierToClassDeclarationFix = AddOpenModifierToClassDeclarationFix.createFactory(); + JetSingleIntentionActionFactory addOpenModifierToClassDeclarationFix = AddOpenModifierToClassDeclarationFix.createFactory(); factories.put(FINAL_SUPERTYPE, addOpenModifierToClassDeclarationFix); factories.put(FINAL_UPPER_BOUND, addOpenModifierToClassDeclarationFix); @@ -214,12 +214,12 @@ public class QuickFixes { factories.put(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED, AddSemicolonAfterFunctionCallFix.createFactory()); - JetIntentionActionFactory changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride(); + JetSingleIntentionActionFactory changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride(); factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix); factories.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix); factories.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, ChangeVariableTypeFix.createFactoryForComponentFunctionReturnTypeMismatch()); - JetIntentionActionFactory changeFunctionReturnTypeFix = ChangeFunctionReturnTypeFix.createFactoryForChangingReturnTypeToUnit(); + JetSingleIntentionActionFactory changeFunctionReturnTypeFix = ChangeFunctionReturnTypeFix.createFactoryForChangingReturnTypeToUnit(); factories.put(RETURN_TYPE_MISMATCH, changeFunctionReturnTypeFix); factories.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, changeFunctionReturnTypeFix); factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, ChangeFunctionReturnTypeFix.createFactoryForReturnTypeMismatchOnOverride()); @@ -236,7 +236,7 @@ public class QuickFixes { factories.put(EXPECTED_PARAMETER_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedParameterTypeMismatch()); factories.put(EXPECTED_RETURN_TYPE_MISMATCH, ChangeTypeFix.createFactoryForExpectedReturnTypeMismatch()); - JetIntentionActionFactory changeFunctionLiteralReturnTypeFix = ChangeFunctionLiteralReturnTypeFix.createFactoryForExpectedOrAssignmentTypeMismatch(); + JetSingleIntentionActionFactory changeFunctionLiteralReturnTypeFix = ChangeFunctionLiteralReturnTypeFix.createFactoryForExpectedOrAssignmentTypeMismatch(); factories.put(EXPECTED_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); factories.put(ASSIGNMENT_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java index f93954651f4..19e77848cd5 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveFunctionBodyFix.java @@ -87,8 +87,8 @@ public class RemoveFunctionBodyFix extends JetIntentionAction { return false; } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java index 6dfe9a14c17..03d61b2998a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveModifierFix.java @@ -103,12 +103,12 @@ public class RemoveModifierFix extends JetIntentionAction } - public static JetIntentionActionFactory createRemoveModifierFromListOwnerFactory(JetKeywordToken modifier) { + public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(JetKeywordToken modifier) { return createRemoveModifierFromListOwnerFactory(modifier, false); } - public static JetIntentionActionFactory createRemoveModifierFromListOwnerFactory(final JetKeywordToken modifier, final boolean isRedundant) { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveModifierFromListOwnerFactory(final JetKeywordToken modifier, final boolean isRedundant) { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { @@ -119,12 +119,12 @@ public class RemoveModifierFix extends JetIntentionAction }; } - public static JetIntentionActionFactory createRemoveModifierFactory() { + public static JetSingleIntentionActionFactory createRemoveModifierFactory() { return createRemoveModifierFactory(false); } - public static JetIntentionActionFactory createRemoveModifierFactory(final boolean isRedundant) { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveModifierFactory(final boolean isRedundant) { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { @@ -139,8 +139,8 @@ public class RemoveModifierFix extends JetIntentionAction }; } - public static JetIntentionActionFactory createRemoveProjectionFactory(final boolean isRedundant) { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveProjectionFactory(final boolean isRedundant) { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { @@ -156,8 +156,8 @@ public class RemoveModifierFix extends JetIntentionAction }; } - public static JetIntentionActionFactory createRemoveVarianceFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveVarianceFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public JetIntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveNullableFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveNullableFix.java index fdabcc18e73..a1f0e08fd8b 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveNullableFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveNullableFix.java @@ -62,8 +62,8 @@ public class RemoveNullableFix extends JetIntentionAction { super.element.replace(type); } - public static JetIntentionActionFactory createFactory(final NullableKind typeOfError) { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory(final NullableKind typeOfError) { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetNullableType nullType = QuickFixUtil.getParentElementOfType(diagnostic, JetNullableType.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java index 6854ba50f3c..6778eec9646 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java @@ -121,8 +121,8 @@ public class RemovePartsFromPropertyFix extends JetIntentionAction } } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { PsiElement element = diagnostic.getPsiElement(); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePsiElementSimpleFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePsiElementSimpleFix.java index 43388a24bb5..40f46346cf6 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePsiElementSimpleFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePsiElementSimpleFix.java @@ -60,8 +60,8 @@ public class RemovePsiElementSimpleFix extends JetIntentionAction { element.delete(); } - public static JetIntentionActionFactory createRemoveImportFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveImportFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetImportDirective directive = QuickFixUtil.getParentElementOfType(diagnostic, JetImportDirective.class); @@ -79,8 +79,8 @@ public class RemovePsiElementSimpleFix extends JetIntentionAction { }; } - public static JetIntentionActionFactory createRemoveSpreadFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveSpreadFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { PsiElement element = diagnostic.getPsiElement(); @@ -92,8 +92,8 @@ public class RemovePsiElementSimpleFix extends JetIntentionAction { }; } - public static JetIntentionActionFactory createRemoveTypeArgumentsFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveTypeArgumentsFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetTypeArgumentList element = QuickFixUtil.getParentElementOfType(diagnostic, JetTypeArgumentList.class); @@ -104,8 +104,8 @@ public class RemovePsiElementSimpleFix extends JetIntentionAction { }; } - public static JetIntentionActionFactory createRemoveVariableFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveVariableFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { final JetProperty expression = QuickFixUtil.getParentElementOfType(diagnostic, JetProperty.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java index 3ad449a3bc4..a2918726a83 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveRightPartOfBinaryExpressionFix.java @@ -57,8 +57,8 @@ public class RemoveRightPartOfBinaryExpressionFix exten } } - public static JetIntentionActionFactory createRemoveCastFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveCastFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetBinaryExpressionWithTypeRHS expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpressionWithTypeRHS.class); @@ -68,8 +68,8 @@ public class RemoveRightPartOfBinaryExpressionFix exten }; } - public static JetIntentionActionFactory createRemoveElvisOperatorFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createRemoveElvisOperatorFactory() { + return new JetSingleIntentionActionFactory() { @Override public JetIntentionAction createAction(Diagnostic diagnostic) { JetBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpression.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveSupertypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveSupertypeFix.java index e6374d65aa4..fd7983caa1e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveSupertypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemoveSupertypeFix.java @@ -63,8 +63,8 @@ public class RemoveSupertypeFix extends JetIntentionAction createAction(Diagnostic diagnostic) { JetDelegationSpecifier superClass = QuickFixUtil.getParentElementOfType(diagnostic, JetDelegationSpecifier.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java index 59c7b6fa088..2c41571125c 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java @@ -82,8 +82,8 @@ public class RenameParameterToMatchOverriddenMethodFix extends JetIntentionActio } @NotNull - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Nullable @Override public IntentionAction createAction(Diagnostic diagnostic) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java index b4c93eb5b5c..7f31feeac9e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceInfixCallFix.java @@ -59,8 +59,8 @@ public class ReplaceInfixCallFix extends JetIntentionAction return true; } - public static JetIntentionActionFactory createFactory() { - return new JetIntentionActionFactory() { + public static JetSingleIntentionActionFactory createFactory() { + return new JetSingleIntentionActionFactory() { @Override public IntentionAction createAction(Diagnostic diagnostic) { JetBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpression.class); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java index 317a2c3cd9d..2bb7c65bfdb 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ReplaceOperationInBinaryExpressionFix.java @@ -18,7 +18,6 @@ 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; @@ -55,8 +54,8 @@ public abstract class ReplaceOperationInBinaryExpressionFix createAction(Diagnostic diagnostic) { JetBinaryExpressionWithTypeRHS expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpressionWithTypeRHS.class); From 6c8096138a2e762316918ca7e067ff02ba177350 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Thu, 9 May 2013 11:05:38 +0200 Subject: [PATCH 55/92] Make ChangeFunctionReturnTypeFix handle function literals --- .../quickfix/ChangeFunctionReturnTypeFix.java | 41 ++++++++++++++----- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java index ad4e875ed06..599ef46e755 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java @@ -22,6 +22,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiErrorElement; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -44,19 +45,32 @@ import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.renderer.DescriptorRenderer; -public class ChangeFunctionReturnTypeFix extends JetIntentionAction { +public class ChangeFunctionReturnTypeFix extends JetIntentionAction { private final JetType type; private final String renderedType; + private final ChangeFunctionLiteralReturnTypeFix changeFunctionLiteralReturnTypeFix; - public ChangeFunctionReturnTypeFix(@NotNull JetNamedFunction element, @NotNull JetType type) { + public ChangeFunctionReturnTypeFix(@NotNull JetFunction element, @NotNull JetType type) { super(element); this.type = type; renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); + if (element instanceof JetFunctionLiteral) { + JetFunctionLiteralExpression functionLiteralExpression = PsiTreeUtil.getParentOfType(element, JetFunctionLiteralExpression.class); + assert functionLiteralExpression != null : "FunctionLiteral outside any FunctionLiteralExpression"; + changeFunctionLiteralReturnTypeFix = new ChangeFunctionLiteralReturnTypeFix(functionLiteralExpression, type); + } + else { + changeFunctionLiteralReturnTypeFix = null; + } } @NotNull @Override public String getText() { + if (changeFunctionLiteralReturnTypeFix != null) { + return changeFunctionLiteralReturnTypeFix.getText(); + } + String functionName = element.getName(); FqName fqName = JetPsiUtil.getFQName(element); if (fqName != null) functionName = fqName.asString(); @@ -79,9 +93,14 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction resolvedCall = context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry); if (resolvedCall == null) return null; - JetNamedFunction componentFunction = (JetNamedFunction) BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); + JetFunction componentFunction = (JetFunction) BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); JetType expectedType = context.get(BindingContext.TYPE, entry.getTypeRef()); if (componentFunction != null && expectedType != null) { return new ChangeFunctionReturnTypeFix(componentFunction, expectedType); @@ -138,7 +157,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction resolvedCall = context.get(BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, expression); if (resolvedCall == null) return null; - JetNamedFunction hasNextFunction = (JetNamedFunction) BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); + JetFunction hasNextFunction = (JetFunction) BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); if (hasNextFunction != null) { return new ChangeFunctionReturnTypeFix(hasNextFunction, KotlinBuiltIns.getInstance().getBooleanType()); } @@ -159,8 +178,8 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction resolvedCall = context.get(BindingContext.RESOLVED_CALL, expression.getOperationReference()); if (resolvedCall == null) return null; PsiElement compareTo = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); - if (!(compareTo instanceof JetNamedFunction)) return null; - return new ChangeFunctionReturnTypeFix((JetNamedFunction) compareTo, KotlinBuiltIns.getInstance().getIntType()); + if (!(compareTo instanceof JetFunction)) return null; + return new ChangeFunctionReturnTypeFix((JetFunction) compareTo, KotlinBuiltIns.getInstance().getIntType()); } }; } @@ -171,7 +190,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction Date: Thu, 9 May 2013 22:07:31 +0200 Subject: [PATCH 56/92] Single factory for TYPE_MISMATCH error --- .../plugin/quickfix/CastExpressionFix.java | 29 ------- .../ChangeFunctionParameterTypeFix.java | 39 --------- .../quickfix/ChangeFunctionReturnTypeFix.java | 20 ----- .../QuickFixFactoryForTypeMismatchError.java | 84 +++++++++++++++++++ .../jet/plugin/quickfix/QuickFixUtil.java | 15 ++++ .../jet/plugin/quickfix/QuickFixes.java | 4 +- ...ypeWithoutChangingFunctionParameterType.kt | 7 ++ ...nLiteralTypeWithoutChangingPropertyType.kt | 7 ++ ...nTypeToMatchReturnTypeOfReturnedLiteral.kt | 4 + ...essionTypeMismatchFunctionParameterType.kt | 6 ++ ...MismatchInIfStatementReturnedByFunction.kt | 7 ++ ...eMismatchInIfStatementReturnedByLiteral.kt | 12 +++ ...ypeWithoutChangingFunctionParameterType.kt | 7 ++ ...nLiteralTypeWithoutChangingPropertyType.kt | 7 ++ ...nTypeToMatchReturnTypeOfReturnedLiteral.kt | 4 + ...CantEvaluateToExpresionThatTypeMismatch.kt | 6 ++ ...essionTypeMismatchFunctionParameterType.kt | 6 ++ ...MismatchInIfStatementReturnedByFunction.kt | 7 ++ ...eMismatchInIfStatementReturnedByLiteral.kt | 12 +++ .../quickfix/QuickFixTestGenerated.java | 35 ++++++++ 20 files changed, 227 insertions(+), 91 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingPropertyType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterReturnedExpressionTypeMismatchFunctionParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByFunction.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByLiteral.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpressionTypeMismatchFunctionParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByFunction.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByLiteral.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java index 6cbf68bf8a9..d58f92e6ebd 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java @@ -20,7 +20,6 @@ import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; -import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -94,32 +93,4 @@ public class CastExpressionFix extends JetIntentionAction { } }; } - - @NotNull - public static JetSingleIntentionActionFactory createFactoryForTypeMismatch() { - return new JetSingleIntentionActionFactory() { - @Nullable - @Override - public IntentionAction createAction(Diagnostic diagnostic) { - assert diagnostic.getFactory() == Errors.TYPE_MISMATCH; - @SuppressWarnings("unchecked") - DiagnosticWithParameters2 diagnosticWithParameters = - (DiagnosticWithParameters2) diagnostic; - JetExpression expression = diagnosticWithParameters.getPsiElement(); - - // we don't want to cast a cast: - if (expression instanceof JetBinaryExpressionWithTypeRHS) { - return null; - } - - // 'x: Int' - TYPE_MISMATCH might be reported on 'x', and we don't want this quickfix to be available: - JetBinaryExpressionWithTypeRHS parentExpressionWithTypeRHS = - PsiTreeUtil.getParentOfType(expression, JetBinaryExpressionWithTypeRHS.class, true); - if (parentExpressionWithTypeRHS != null && parentExpressionWithTypeRHS.getLeft() == expression) { - return null; - } - return new CastExpressionFix(expression, diagnosticWithParameters.getA()); - } - }; - } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java index 3c7d2b2ba67..3375089e6f7 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionParameterTypeFix.java @@ -16,21 +16,16 @@ 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.PsiFile; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; -import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.renderer.DescriptorRenderer; public class ChangeFunctionParameterTypeFix extends JetIntentionAction { @@ -68,38 +63,4 @@ public class ChangeFunctionParameterTypeFix extends JetIntentionAction } }; } - - @NotNull - public static JetSingleIntentionActionFactory createFactoryForTypeMismatch() { - return new JetSingleIntentionActionFactory() { - @Nullable - @Override - public IntentionAction createAction(Diagnostic diagnostic) { - JetExpression expression = (JetExpression) diagnostic.getPsiElement(); - JetNamedFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetNamedFunction.class); - - if (function != null && (function.getInitializer() == expression || expression.getParent() instanceof JetReturnExpression)) { - BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) diagnostic.getPsiFile()).getBindingContext(); - JetType type = context.get(BindingContext.EXPRESSION_TYPE, expression); - assert type != null : "Expression type mismatch, but expression has no type"; - return new ChangeFunctionReturnTypeFix(function, type); - } - return null; - } - }; - } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java new file mode 100644 index 00000000000..1f0ae66d09b --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -0,0 +1,84 @@ +/* + * Copyright 2010-2013 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.quickfix; + +import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters2; +import org.jetbrains.jet.lang.diagnostics.Errors; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; + +import java.util.LinkedList; +import java.util.List; + +public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsFactory { + @NotNull + @Override + public List createActions(Diagnostic diagnostic) { + List actions = new LinkedList(); + + assert diagnostic.getFactory() == Errors.TYPE_MISMATCH; + @SuppressWarnings("unchecked") + DiagnosticWithParameters2 diagnosticWithParameters = + (DiagnosticWithParameters2) diagnostic; + JetExpression expression = diagnosticWithParameters.getPsiElement(); + JetType expectedType = diagnosticWithParameters.getA(); + JetType expressionType = diagnosticWithParameters.getB(); + BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) diagnostic.getPsiFile()).getBindingContext(); + + // We don't want to cast a cast or type-asserted expression: + if (!(expression instanceof JetBinaryExpressionWithTypeRHS) && !(expression.getParent() instanceof JetBinaryExpressionWithTypeRHS)) { + actions.add(new CastExpressionFix(expression, expectedType)); + } + + // Mismatch in returned expression: + JetFunction function = PsiTreeUtil.getParentOfType(expression, JetFunction.class, true); + if (function != null && QuickFixUtil.canFunctionReturnExpression(function, expression)) { + actions.add(new ChangeFunctionReturnTypeFix(function, expressionType)); + } + + // Change type of a function parameter in case TYPE_MISMATCH is reported on expression passed as value argument of call. + // 1) When an argument is a dangling function literal: + JetFunctionLiteralExpression functionLiteralExpression = + QuickFixUtil.getParentElementOfType(diagnostic, JetFunctionLiteralExpression.class); + if (functionLiteralExpression != null && functionLiteralExpression.getBodyExpression() == expression) { + JetParameter correspondingParameter = + QuickFixUtil.getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(functionLiteralExpression); + JetType functionLiteralExpressionType = context.get(BindingContext.EXPRESSION_TYPE, functionLiteralExpression); + if (correspondingParameter != null && functionLiteralExpressionType != null) { + actions.add(new ChangeFunctionParameterTypeFix(correspondingParameter, functionLiteralExpressionType)); + } + } + // 2) When an argument is passed inside value argument list: + else { + JetValueArgument valueArgument = QuickFixUtil.getParentElementOfType(diagnostic, JetValueArgument.class); + if (valueArgument != null && valueArgument.getArgumentExpression() == expression) { + JetParameter correspondingParameter = QuickFixUtil.getFunctionParameterCorrespondingToValueArgumentPassedInCall(valueArgument); + JetType valueArgumentType = context.get(BindingContext.EXPRESSION_TYPE, valueArgument.getArgumentExpression()); + if (correspondingParameter != null && valueArgumentType != null) { + actions.add(new ChangeFunctionParameterTypeFix(correspondingParameter, valueArgumentType)); + } + } + } + return actions; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index beb270a8724..a7217ba7006 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -174,4 +174,19 @@ public class QuickFixUtil { } return true; } + + public static boolean canFunctionReturnExpression(@NotNull JetFunction function, @NotNull JetExpression expression) { + if (function instanceof JetFunctionLiteral) { + JetBlockExpression functionLiteralBody = ((JetFunctionLiteral) function).getBodyExpression(); + PsiElement returnedElement = functionLiteralBody == null ? null : functionLiteralBody.getLastChild(); + return returnedElement instanceof JetExpression && canEvaluateTo((JetExpression) returnedElement, expression); + } + else { + if (function instanceof JetWithExpressionInitializer && canEvaluateTo(((JetWithExpressionInitializer) function).getInitializer(), expression)) { + return true; + } + JetReturnExpression returnExpression = PsiTreeUtil.getParentOfType(expression, JetReturnExpression.class); + return returnExpression != null && canEvaluateTo(returnExpression.getReturnedExpression(), expression); + } + } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index 7a4ce23f253..ad2eb561f5a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -226,7 +226,6 @@ public class QuickFixes { factories.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForComponentFunctionReturnTypeMismatch()); factories.put(HAS_NEXT_FUNCTION_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForHasNextFunctionTypeMismatch()); factories.put(COMPARE_TO_TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForCompareToTypeMismatch()); - factories.put(TYPE_MISMATCH, ChangeFunctionReturnTypeFix.createFactoryForTypeMismatch()); factories.put(TOO_MANY_ARGUMENTS, ChangeFunctionSignatureFix.createFactory()); factories.put(NO_VALUE_FOR_PARAMETER, ChangeFunctionSignatureFix.createFactory()); @@ -240,10 +239,9 @@ public class QuickFixes { factories.put(EXPECTED_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); factories.put(ASSIGNMENT_TYPE_MISMATCH, changeFunctionLiteralReturnTypeFix); - factories.put(TYPE_MISMATCH, ChangeFunctionParameterTypeFix.createFactory()); + factories.put(TYPE_MISMATCH, new QuickFixFactoryForTypeMismatchError()); factories.put(AUTOCAST_IMPOSSIBLE, CastExpressionFix.createFactoryForAutoCastImpossible()); - factories.put(TYPE_MISMATCH, CastExpressionFix.createFactoryForTypeMismatch()); factories.put(PLATFORM_CLASS_MAPPED_TO_KOTLIN, MapPlatformClassToKotlinFix.createFactory()); diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt new file mode 100644 index 00000000000..b2b6552068c --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt @@ -0,0 +1,7 @@ +// "Change function literal return type to 'String'" "true" +fun foo(f: (String) -> Any) { + foo { + (s: String): String -> + s + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingPropertyType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingPropertyType.kt new file mode 100644 index 00000000000..35be90c1bea --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionLiteralTypeWithoutChangingPropertyType.kt @@ -0,0 +1,7 @@ +// "Change function literal return type to 'String'" "true" +fun foo() { + val f: (String) -> String = { + (s: Any): String -> + "" + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt new file mode 100644 index 00000000000..5c7182093c5 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt @@ -0,0 +1,4 @@ +// "Change 'foo' function return type to '() -> Any'" "true" +fun foo(x: Any): () -> Any { + return {x} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterReturnedExpressionTypeMismatchFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterReturnedExpressionTypeMismatchFunctionParameterType.kt new file mode 100644 index 00000000000..16a4b270648 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterReturnedExpressionTypeMismatchFunctionParameterType.kt @@ -0,0 +1,6 @@ +// "Change parameter 'f' type of function 'foo' to '() -> String'" "true" +fun foo(f: () -> String) { + foo { + "" + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByFunction.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByFunction.kt new file mode 100644 index 00000000000..031dded208b --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByFunction.kt @@ -0,0 +1,7 @@ +// "Change 'boo' function return type to 'String'" "true" +fun boo(): String { + return ((if (true) { + val a = "" + a + } else "")) +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByLiteral.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByLiteral.kt new file mode 100644 index 00000000000..19f21d70c71 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterTypeMismatchInIfStatementReturnedByLiteral.kt @@ -0,0 +1,12 @@ +// "Change 'f' type to '(Int, Int) -> (String) -> Int'" "true" +fun foo() { + val f: (Int, Int) -> (String) -> Int = { + (a: Int, b: Int): (String) -> Int -> + val x = {(s: String) -> 42} + if (true) x + else if (true) x else { + var y = 42 + if (true) x else x + } + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt new file mode 100644 index 00000000000..0a04b9f473b --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt @@ -0,0 +1,7 @@ +// "Change function literal return type to 'String'" "true" +fun foo(f: (String) -> Any) { + foo { + (s: String): Int -> + s + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt new file mode 100644 index 00000000000..dbec7994ac1 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt @@ -0,0 +1,7 @@ +// "Change function literal return type to 'String'" "true" +fun foo() { + val f: (String) -> String = { + (s: Any): Int -> + "" + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt new file mode 100644 index 00000000000..44c4c565685 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt @@ -0,0 +1,4 @@ +// "Change 'foo' function return type to '() -> Any'" "true" +fun foo(x: Any): () -> Int { + return {x} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt new file mode 100644 index 00000000000..8161c29c287 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt @@ -0,0 +1,6 @@ +// "Change function 'foo' return type to 'String'" "false" +// ERROR: Type mismatch.
Required:jet.Int
Found:jet.String
+// ACTION: Disable 'Replace 'if' with 'when'' +// ACTION: Edit intention settings +// ACTION: Replace 'if' with 'when' +fun foo(): Int = if (true) "": Int else 4 \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpressionTypeMismatchFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpressionTypeMismatchFunctionParameterType.kt new file mode 100644 index 00000000000..cb39787a072 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpressionTypeMismatchFunctionParameterType.kt @@ -0,0 +1,6 @@ +// "Change parameter 'f' type of function 'foo' to '() -> String'" "true" +fun foo(f: () -> Int) { + foo { + "" + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByFunction.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByFunction.kt new file mode 100644 index 00000000000..8a4869a7439 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByFunction.kt @@ -0,0 +1,7 @@ +// "Change 'boo' function return type to 'String'" "true" +fun boo(): Int { + return ((if (true) { + val a = "" + a + } else "")) +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByLiteral.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByLiteral.kt new file mode 100644 index 00000000000..ae1c5c6a142 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByLiteral.kt @@ -0,0 +1,12 @@ +// "Change 'f' type to '(Int, Int) -> (String) -> Int'" "true" +fun foo() { + val f: () -> Long = { + (a: Int, b: Int): Long -> + val x = {(s: String) -> 42} + if (true) x + else if (true) x else { + var y = 42 + if (true) x else x + } + } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 810c38bc41d..7dbabee2862 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1421,16 +1421,51 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeAssignmentTypeMismatch.kt"); } + @TestMetadata("beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt") + public void testChangeFunctionLiteralTypeWithoutChangingFunctionParameterType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingFunctionParameterType.kt"); + } + + @TestMetadata("beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt") + public void testChangeFunctionLiteralTypeWithoutChangingPropertyType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionLiteralTypeWithoutChangingPropertyType.kt"); + } + @TestMetadata("beforeChangeFunctionReturnTypeToFunctionType.kt") public void testChangeFunctionReturnTypeToFunctionType() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToFunctionType.kt"); } + @TestMetadata("beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt") + public void testChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt"); + } + @TestMetadata("beforeExpectedTypeMismatch.kt") public void testExpectedTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt"); } + @TestMetadata("beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt") + public void testReturnedExpresionCantEvaluateToExpresionThatTypeMismatch() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt"); + } + + @TestMetadata("beforeReturnedExpressionTypeMismatchFunctionParameterType.kt") + public void testReturnedExpressionTypeMismatchFunctionParameterType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpressionTypeMismatchFunctionParameterType.kt"); + } + + @TestMetadata("beforeTypeMismatchInIfStatementReturnedByFunction.kt") + public void testTypeMismatchInIfStatementReturnedByFunction() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByFunction.kt"); + } + + @TestMetadata("beforeTypeMismatchInIfStatementReturnedByLiteral.kt") + public void testTypeMismatchInIfStatementReturnedByLiteral() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInIfStatementReturnedByLiteral.kt"); + } + @TestMetadata("beforeTypeMismatchInInitializer.kt") public void testTypeMismatchInInitializer() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeTypeMismatchInInitializer.kt"); From d3492d8e6f708d861641aeea0b2fce33f67cbc91 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Thu, 9 May 2013 22:24:15 +0200 Subject: [PATCH 57/92] QuickFix: change property type to match it's initializer type --- .../quickfix/QuickFixFactoryForTypeMismatchError.java | 6 ++++++ .../quickfix/typeMismatch/afterPropertyTypeMismatch.kt | 4 ++++ .../quickfix/typeMismatch/beforePropertyTypeMismatch.kt | 4 ++++ .../jet/plugin/quickfix/QuickFixTestGenerated.java | 5 +++++ 4 files changed, 19 insertions(+) create mode 100644 idea/testData/quickfix/typeMismatch/afterPropertyTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/beforePropertyTypeMismatch.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java index 1f0ae66d09b..7ba9769d05e 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -50,6 +50,12 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF actions.add(new CastExpressionFix(expression, expectedType)); } + // Property initializer type mismatch property type: + JetProperty property = PsiTreeUtil.getParentOfType(expression, JetProperty.class); + if (property != null && QuickFixUtil.canEvaluateTo(property.getInitializer(), expression)) { + actions.add(new ChangeVariableTypeFix(property, expressionType)); + } + // Mismatch in returned expression: JetFunction function = PsiTreeUtil.getParentOfType(expression, JetFunction.class, true); if (function != null && QuickFixUtil.canFunctionReturnExpression(function, expression)) { diff --git a/idea/testData/quickfix/typeMismatch/afterPropertyTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/afterPropertyTypeMismatch.kt new file mode 100644 index 00000000000..4302b75770c --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/afterPropertyTypeMismatch.kt @@ -0,0 +1,4 @@ +// "Change 'f' type to '(Long) -> Unit'" "true" +fun foo() { + var f: (Long) -> Unit = if (true) { (x: Long) -> } else { (x: Long) -> } +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/beforePropertyTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/beforePropertyTypeMismatch.kt new file mode 100644 index 00000000000..a1ffc07759c --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/beforePropertyTypeMismatch.kt @@ -0,0 +1,4 @@ +// "Change 'f' type to '(Long) -> Unit'" "true" +fun foo() { + var f: Int = if (true) { (x: Long) -> } else { (x: Long) -> } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 7dbabee2862..034c2451009 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1286,6 +1286,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/beforeNoReturnInFunctionWithBlockBody.kt"); } + @TestMetadata("beforePropertyTypeMismatch.kt") + public void testPropertyTypeMismatch() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforePropertyTypeMismatch.kt"); + } + @TestMetadata("beforeReturnTypeMismatch.kt") public void testReturnTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/beforeReturnTypeMismatch.kt"); From 76e648ded30e392d39be09065fcb2de6fea3ed66 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Fri, 10 May 2013 00:42:40 +0200 Subject: [PATCH 58/92] QuickFix: change overloaded operator parameter type or return type --- .../QuickFixFactoryForTypeMismatchError.java | 29 +++++++++++++++++++ .../afterChangeNotFunctionReturnType.kt | 7 +++++ .../afterChangePlusFunctionReturnType.kt | 8 +++++ .../afterChangeTimesFunctionParameterType.kt | 6 ++++ .../beforeChangeNotFunctionReturnType.kt | 7 +++++ .../beforeChangePlusFunctionReturnType.kt | 8 +++++ .../beforeChangeTimesFunctionParameterType.kt | 6 ++++ .../quickfix/QuickFixTestGenerated.java | 26 ++++++++++++++++- 8 files changed, 96 insertions(+), 1 deletion(-) create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeNotFunctionReturnType.kt create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangePlusFunctionReturnType.kt create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeTimesFunctionParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeNotFunctionReturnType.kt create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangePlusFunctionReturnType.kt create mode 100644 idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeTimesFunctionParameterType.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java index 7ba9769d05e..613136a1bd3 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -17,13 +17,17 @@ package org.jetbrains.jet.plugin.quickfix; import com.intellij.codeInsight.intention.IntentionAction; +import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters2; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; @@ -62,6 +66,31 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF actions.add(new ChangeFunctionReturnTypeFix(function, expressionType)); } + // Fixing overloaded operators: + if (expression instanceof JetOperationExpression) { + ResolvedCall resolvedCall = + context.get(BindingContext.RESOLVED_CALL, ((JetOperationExpression) expression).getOperationReference()); + if (resolvedCall != null) { + PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getResultingDescriptor()); + if (declaration instanceof JetFunction) { + actions.add(new ChangeFunctionReturnTypeFix((JetFunction) declaration, expectedType)); + } + } + } + if (expression.getParent() instanceof JetBinaryExpression) { + JetBinaryExpression parentBinary = (JetBinaryExpression) expression.getParent(); + if (parentBinary.getRight() == expression) { + ResolvedCall resolvedCall = context.get(BindingContext.RESOLVED_CALL, parentBinary.getOperationReference()); + if (resolvedCall != null) { + PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getResultingDescriptor()); + if (declaration instanceof JetFunction) { + JetParameter binaryOperatorParameter = ((JetFunction) declaration).getValueParameterList().getParameters().get(0); + actions.add(new ChangeFunctionParameterTypeFix(binaryOperatorParameter, expressionType)); + } + } + } + } + // Change type of a function parameter in case TYPE_MISMATCH is reported on expression passed as value argument of call. // 1) When an argument is a dangling function literal: JetFunctionLiteralExpression functionLiteralExpression = diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeNotFunctionReturnType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeNotFunctionReturnType.kt new file mode 100644 index 00000000000..2e02e549264 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeNotFunctionReturnType.kt @@ -0,0 +1,7 @@ +// "Change 'A.not' function return type to 'A'" "true" +trait A { + fun not(): A + fun times(a: A): A +} + +fun foo(a: A): A = a * !(if (true) a else a) \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangePlusFunctionReturnType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangePlusFunctionReturnType.kt new file mode 100644 index 00000000000..5f841fe38b4 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangePlusFunctionReturnType.kt @@ -0,0 +1,8 @@ +// "Change 'A.plus' function return type to '() -> Int'" "true" +trait A { + fun plus(a: A): () -> Int +} + +fun foo(a: A): () -> Int { + return a + a +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeTimesFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeTimesFunctionParameterType.kt new file mode 100644 index 00000000000..a0178c297d5 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/afterChangeTimesFunctionParameterType.kt @@ -0,0 +1,6 @@ +// "Change parameter 'a' type of function 'A.times' to 'String'" "true" +trait A { + fun times(a: String): A +} + +fun foo(a: A): A = a * "" \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeNotFunctionReturnType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeNotFunctionReturnType.kt new file mode 100644 index 00000000000..3fcbddff06c --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeNotFunctionReturnType.kt @@ -0,0 +1,7 @@ +// "Change 'A.not' function return type to 'A'" "true" +trait A { + fun not(): String + fun times(a: A): A +} + +fun foo(a: A): A = a * !(if (true) a else a) \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangePlusFunctionReturnType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangePlusFunctionReturnType.kt new file mode 100644 index 00000000000..c83d83f0c41 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangePlusFunctionReturnType.kt @@ -0,0 +1,8 @@ +// "Change 'A.plus' function return type to '() -> Int'" "true" +trait A { + fun plus(a: A): String +} + +fun foo(a: A): () -> Int { + return a + a +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeTimesFunctionParameterType.kt b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeTimesFunctionParameterType.kt new file mode 100644 index 00000000000..837fc7af446 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeTimesFunctionParameterType.kt @@ -0,0 +1,6 @@ +// "Change parameter 'a' type of function 'A.times' to 'String'" "true" +trait A { + fun times(a: A): A +} + +fun foo(a: A): A = a * "" \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 034c2451009..a4eb2f2f42a 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1240,7 +1240,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } @TestMetadata("idea/testData/quickfix/typeMismatch") - @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.FunctionParameterTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) + @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.FixOverloadedOperator.class, TypeMismatch.FunctionParameterTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) public static class TypeMismatch extends AbstractQuickFixTest { public void testAllFilesPresentInTypeMismatch() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); @@ -1382,6 +1382,29 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } + @TestMetadata("idea/testData/quickfix/typeMismatch/fixOverloadedOperator") + public static class FixOverloadedOperator extends AbstractQuickFixTest { + public void testAllFilesPresentInFixOverloadedOperator() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/fixOverloadedOperator"), Pattern.compile("^before(\\w+)\\.kt$"), true); + } + + @TestMetadata("beforeChangeNotFunctionReturnType.kt") + public void testChangeNotFunctionReturnType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeNotFunctionReturnType.kt"); + } + + @TestMetadata("beforeChangePlusFunctionReturnType.kt") + public void testChangePlusFunctionReturnType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangePlusFunctionReturnType.kt"); + } + + @TestMetadata("beforeChangeTimesFunctionParameterType.kt") + public void testChangeTimesFunctionParameterType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/fixOverloadedOperator/beforeChangeTimesFunctionParameterType.kt"); + } + + } + @TestMetadata("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch") public static class FunctionParameterTypeMismatch extends AbstractQuickFixTest { public void testAllFilesPresentInFunctionParameterTypeMismatch() throws Exception { @@ -1488,6 +1511,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { suite.addTestSuite(TypeMismatch.class); suite.addTestSuite(Casts.class); suite.addTestSuite(ComponentFunctionReturnTypeMismatch.class); + suite.addTestSuite(FixOverloadedOperator.class); suite.addTestSuite(FunctionParameterTypeMismatch.class); suite.addTestSuite(TypeMismatchOnReturnedExpression.class); return suite; From 1a5d5159727ec0c6f33331787f8e10582b45681b Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Fri, 10 May 2013 00:57:45 +0200 Subject: [PATCH 59/92] QuickFix: change function return type to match expexted type of call --- .../QuickFixFactoryForTypeMismatchError.java | 12 ++++++++++++ ...ngeFunctionReturnTypeToMatchExpectedTypeOfCall.kt | 3 +++ ...ngeFunctionReturnTypeToMatchExpectedTypeOfCall.kt | 3 +++ .../jet/plugin/quickfix/QuickFixTestGenerated.java | 5 +++++ 4 files changed, 23 insertions(+) create mode 100644 idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt create mode 100644 idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java index 613136a1bd3..70c1c6632b0 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -91,6 +91,18 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF } } + // Change function return type when TYPE_MISMATCH is reported on call expression: + if (expression instanceof JetCallExpression) { + ResolvedCall resolvedCall = + context.get(BindingContext.RESOLVED_CALL, ((JetCallExpression) expression).getCalleeExpression()); + if (resolvedCall != null) { + PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getResultingDescriptor()); + if (declaration instanceof JetFunction) { + actions.add(new ChangeFunctionReturnTypeFix((JetFunction) declaration, expectedType)); + } + } + } + // Change type of a function parameter in case TYPE_MISMATCH is reported on expression passed as value argument of call. // 1) When an argument is a dangling function literal: JetFunctionLiteralExpression functionLiteralExpression = diff --git a/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt b/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt new file mode 100644 index 00000000000..e043c28dd7b --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/afterChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt @@ -0,0 +1,3 @@ +// "Change 'bar' function return type to 'String'" "true" +fun bar(): String = "" +fun foo(): String = bar() \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt new file mode 100644 index 00000000000..dcd7a090c5b --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt @@ -0,0 +1,3 @@ +// "Change 'bar' function return type to 'String'" "true" +fun bar(): Any = "" +fun foo(): String = bar() \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index a4eb2f2f42a..a7a0898cffe 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1251,6 +1251,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/beforeChangeFunctionLiteralParameterTypeToFunctionType.kt"); } + @TestMetadata("beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt") + public void testChangeFunctionReturnTypeToMatchExpectedTypeOfCall() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforeChangeFunctionReturnTypeToMatchExpectedTypeOfCall.kt"); + } + @TestMetadata("beforeChangeReturnTypeWhenFunctionNameIsMissing.kt") public void testChangeReturnTypeWhenFunctionNameIsMissing() throws Exception { doTest("idea/testData/quickfix/typeMismatch/beforeChangeReturnTypeWhenFunctionNameIsMissing.kt"); From 0d65a1b7895ed6bdc68f47cf4f6e5c90de251bc2 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 15 May 2013 20:25:34 +0200 Subject: [PATCH 60/92] Better text for ChangeVariableTypeFix --- .../jet/plugin/quickfix/ChangeVariableTypeFix.java | 7 ++++++- .../afterChangeOverridingPropertyTypeToFunctionType.kt | 2 +- .../afterPropertyReturnTypeMismatchOnOverride.kt | 2 +- .../afterPropertyTypeMismatchOnOverrideIntLong.kt | 2 +- .../afterPropertyTypeMismatchOnOverrideIntUnit.kt | 2 +- .../beforeChangeOverridingPropertyTypeToFunctionType.kt | 2 +- .../beforePropertyReturnTypeMismatchOnOverride.kt | 2 +- .../beforePropertyTypeMismatchOnOverrideIntLong.kt | 2 +- .../beforePropertyTypeMismatchOnOverrideIntUnit.kt | 2 +- 9 files changed, 14 insertions(+), 9 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index c70d024f7a6..4df5e245e88 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; @@ -48,7 +49,11 @@ public class ChangeVariableTypeFix extends JetIntentionAction Int'" "true" +// "Change 'B.x' type to '(String) -> Int'" "true" trait A { var x: (String) -> Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyReturnTypeMismatchOnOverride.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyReturnTypeMismatchOnOverride.kt index 9dbb3cbe563..0f79cd40f9d 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyReturnTypeMismatchOnOverride.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyReturnTypeMismatchOnOverride.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'A.x' type to 'Int'" "true" trait X { val x: Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt index e810c22a1ee..80d3b2e6a05 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntLong.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'B.x' type to 'Int'" "true" abstract class A { abstract var x : Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt index 8296b837504..f37ab4f9ff0 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterPropertyTypeMismatchOnOverrideIntUnit.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'B.x' type to 'Int'" "true" abstract class A { abstract var x : Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt index 86cf8bd43da..6a6b1155d01 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to '(String) -> Int'" "true" +// "Change 'B.x' type to '(String) -> Int'" "true" trait A { var x: (String) -> Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt index afd321e5cfa..4378d809f4a 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'A.x' type to 'Int'" "true" trait X { val x: Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt index db0eabb5856..a70d8d74a05 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntLong.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'B.x' type to 'Int'" "true" abstract class A { abstract var x : Int } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt index 39289180da2..469a62099b0 100644 --- a/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyTypeMismatchOnOverrideIntUnit.kt @@ -1,4 +1,4 @@ -// "Change 'x' type to 'Int'" "true" +// "Change 'B.x' type to 'Int'" "true" abstract class A { abstract var x : Int } From 9fdbd01660c21f21091c53cdf2a3eca2565bd4e4 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 15 May 2013 21:16:41 +0200 Subject: [PATCH 61/92] QuickFix: change type of overridden property to type of overridding property --- .../quickfix/ChangeVariableTypeFix.java | 48 +++++++++++++++---- .../jet/plugin/quickfix/QuickFixes.java | 2 +- .../afterChangeOverriddenPropertyType.kt | 12 +++++ ...ChangeMultipleOverriddenPropertiesTypes.kt | 14 ++++++ .../beforeChangeOverriddenPropertyType.kt | 12 +++++ .../quickfix/QuickFixTestGenerated.java | 10 ++++ 6 files changed, 89 insertions(+), 9 deletions(-) create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index 4df5e245e88..e30cd47a574 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -25,6 +25,7 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -32,12 +33,16 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.renderer.DescriptorRenderer; +import java.util.LinkedList; +import java.util.List; + public class ChangeVariableTypeFix extends JetIntentionAction { private final String renderedType; @@ -90,16 +95,43 @@ public class ChangeVariableTypeFix extends JetIntentionAction createActions(Diagnostic diagnostic) { + List actions = new LinkedList(); + JetProperty property = QuickFixUtil.getParentElementOfType(diagnostic, JetProperty.class); - if (property == null) return null; - BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(property); - JetType type = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, property); - return type == null ? null : new ChangeVariableTypeFix(property, type); + if (property != null) { + BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(property); + JetType lowerBoundOfOverriddenPropertiesTypes = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, property); + if (lowerBoundOfOverriddenPropertiesTypes != null) { + actions.add(new ChangeVariableTypeFix(property, lowerBoundOfOverriddenPropertiesTypes)); + } + + PropertyDescriptor descriptor = (PropertyDescriptor) context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property); + assert descriptor != null : "Descriptor of property not available in binding context"; + JetType propertyType = descriptor.getReturnType(); + assert propertyType != null : "Property type cannot be null if it mismatch something"; + + List overriddenMismatchingProperties = new LinkedList(); + for (PropertyDescriptor overriddenProperty: descriptor.getOverriddenDescriptors()) { + JetType overriddenPropertyType = overriddenProperty.getReturnType(); + if (overriddenPropertyType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(propertyType, overriddenPropertyType)) { + overriddenMismatchingProperties.add(overriddenProperty); + } + } + + if (overriddenMismatchingProperties.size() == 1) { + JetProperty overriddenProperty = + (JetProperty) BindingContextUtils.descriptorToDeclaration(context, overriddenMismatchingProperties.get(0)); + if (overriddenProperty != null) { + actions.add(new ChangeVariableTypeFix(overriddenProperty, propertyType)); + } + } + } + return actions; } }; } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java index ad2eb561f5a..63f87c80c17 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixes.java @@ -214,7 +214,7 @@ public class QuickFixes { factories.put(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED, AddSemicolonAfterFunctionCallFix.createFactory()); - JetSingleIntentionActionFactory changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride(); + JetIntentionActionsFactory changeVariableTypeFix = ChangeVariableTypeFix.createFactoryForPropertyOrReturnTypeMismatchOnOverride(); factories.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix); factories.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, changeVariableTypeFix); factories.put(COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, ChangeVariableTypeFix.createFactoryForComponentFunctionReturnTypeMismatch()); diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt new file mode 100644 index 00000000000..6a3586ed492 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt @@ -0,0 +1,12 @@ +// "Change 'B.x' type to '(Int) -> Int'" "true" +trait A { + val x: (Int) -> Int +} + +trait B { + val x: (Int) -> Int +} + +trait C : A, B { + override val x: (Int) -> Int +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt new file mode 100644 index 00000000000..9fe0b5a6264 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt @@ -0,0 +1,14 @@ +// "Change 'A.x' type to '(Int) -> Int'" "false" +// ACTION: Change 'C.x' type to '(String) -> Int' +// ERROR: Return type is '(jet.Int) → jet.Int', which is not a subtype of overridden
internal abstract val x: (jet.String) → jet.Int defined in A +trait A { + val x: (String) -> Int +} + +trait B { + val x: (String) -> Any +} + +trait C : A, B { + override val x: (Int) -> Int +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt new file mode 100644 index 00000000000..9216f429193 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt @@ -0,0 +1,12 @@ +// "Change 'B.x' type to '(Int) -> Int'" "true" +trait A { + val x: (Int) -> Int +} + +trait B { + val x: (String) -> Any +} + +trait C : A, B { + override val x: (Int) -> Int +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index a7a0898cffe..19755e455eb 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1018,6 +1018,16 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^before(\\w+)\\.kt$"), true); } + @TestMetadata("beforeCantChangeMultipleOverriddenPropertiesTypes.kt") + public void testCantChangeMultipleOverriddenPropertiesTypes() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt"); + } + + @TestMetadata("beforeChangeOverriddenPropertyType.kt") + public void testChangeOverriddenPropertyType() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt"); + } + @TestMetadata("beforeChangeOverridingPropertyTypeToFunctionType.kt") public void testChangeOverridingPropertyTypeToFunctionType() throws Exception { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt"); From e08d9ee8da49df82f6f6e5d3f92700745a1a8363 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 15 May 2013 21:43:37 +0200 Subject: [PATCH 62/92] Fix quickFix for PROPERTY_TYPE_MISMATCH_ON_OVERRIDE --- .../quickfix/ChangeVariableTypeFix.java | 30 ++++++++++++------- ... => afterChangeOverriddenPropertyType1.kt} | 0 .../afterChangeOverriddenPropertyType2.kt | 12 ++++++++ ...enPropertyTypeToMatchOverridingProperty.kt | 13 ++++++++ ...ePropertyTypeToMatchOverridenProperties.kt | 13 ++++++++ ...=> beforeChangeOverriddenPropertyType1.kt} | 0 .../beforeChangeOverriddenPropertyType2.kt | 12 ++++++++ .../quickfix/QuickFixTestGenerated.java | 21 +++++++++++-- 8 files changed, 88 insertions(+), 13 deletions(-) rename idea/testData/quickfix/override/typeMismatchOnOverride/{afterChangeOverriddenPropertyType.kt => afterChangeOverriddenPropertyType1.kt} (100%) create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType2.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt rename idea/testData/quickfix/override/typeMismatchOnOverride/{beforeChangeOverriddenPropertyType.kt => beforeChangeOverriddenPropertyType1.kt} (100%) create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType2.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index e30cd47a574..9d9f5cdfd9f 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -106,9 +106,6 @@ public class ChangeVariableTypeFix extends JetIntentionAction overriddenMismatchingProperties = new LinkedList(); + boolean canChangeOverriddenPropertyType = true; for (PropertyDescriptor overriddenProperty: descriptor.getOverriddenDescriptors()) { JetType overriddenPropertyType = overriddenProperty.getReturnType(); - if (overriddenPropertyType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(propertyType, overriddenPropertyType)) { - overriddenMismatchingProperties.add(overriddenProperty); + if (overriddenPropertyType != null) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(propertyType, overriddenPropertyType)) { + overriddenMismatchingProperties.add(overriddenProperty); + } + else if (overriddenProperty.isVar() && !JetTypeChecker.INSTANCE.equalTypes(overriddenPropertyType, propertyType)) { + canChangeOverriddenPropertyType = false; + } + if (overriddenProperty.isVar() && lowerBoundOfOverriddenPropertiesTypes != null && + !JetTypeChecker.INSTANCE.equalTypes(lowerBoundOfOverriddenPropertiesTypes, overriddenPropertyType)) { + lowerBoundOfOverriddenPropertiesTypes = null; + } } } - if (overriddenMismatchingProperties.size() == 1) { - JetProperty overriddenProperty = - (JetProperty) BindingContextUtils.descriptorToDeclaration(context, overriddenMismatchingProperties.get(0)); - if (overriddenProperty != null) { - actions.add(new ChangeVariableTypeFix(overriddenProperty, propertyType)); + if (lowerBoundOfOverriddenPropertiesTypes != null) { + actions.add(new ChangeVariableTypeFix(property, lowerBoundOfOverriddenPropertiesTypes)); + } + + if (overriddenMismatchingProperties.size() == 1 && canChangeOverriddenPropertyType) { + PsiElement overriddenProperty = BindingContextUtils.descriptorToDeclaration(context, overriddenMismatchingProperties.get(0)); + if (overriddenProperty instanceof JetProperty) { + actions.add(new ChangeVariableTypeFix((JetProperty) overriddenProperty, propertyType)); } } } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType1.kt similarity index 100% rename from idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType.kt rename to idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType1.kt diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType2.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType2.kt new file mode 100644 index 00000000000..fd1e09a06ce --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeOverriddenPropertyType2.kt @@ -0,0 +1,12 @@ +// "Change 'A.x' type to 'String'" "true" +trait A { + var x: String +} + +trait B { + var x: String +} + +trait C : A, B { + override var x: String +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt new file mode 100644 index 00000000000..1a7149f1ca8 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt @@ -0,0 +1,13 @@ +// "Change 'A.x' type to 'String'" "false" +// ERROR: Var-property type is 'jet.String', which is not a type of overridden
internal abstract var x: jet.Int defined in A +trait A { + var x: Int +} + +trait B { + var x: Any +} + +trait C : A, B { + override var x: String +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt new file mode 100644 index 00000000000..c47babf6e69 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt @@ -0,0 +1,13 @@ +// "Change 'C.x' type to 'String'" "false" +// ERROR: Var-property type is 'jet.Int', which is not a type of overridden
internal abstract var x: jet.String defined in A +trait A { + var x: String +} + +trait B { + var x: Any +} + +trait C : A, B { + override var x: Int +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType1.kt similarity index 100% rename from idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt rename to idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType1.kt diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType2.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType2.kt new file mode 100644 index 00000000000..df144be7ce6 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType2.kt @@ -0,0 +1,12 @@ +// "Change 'A.x' type to 'String'" "true" +trait A { + var x: Int +} + +trait B { + var x: String +} + +trait C : A, B { + override var x: String +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 19755e455eb..9b22cc5d85a 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1023,9 +1023,24 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeMultipleOverriddenPropertiesTypes.kt"); } - @TestMetadata("beforeChangeOverriddenPropertyType.kt") - public void testChangeOverriddenPropertyType() throws Exception { - doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType.kt"); + @TestMetadata("beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt") + public void testCantChangeOverriddenPropertyTypeToMatchOverridingProperty() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeOverriddenPropertyTypeToMatchOverridingProperty.kt"); + } + + @TestMetadata("beforeCantChangePropertyTypeToMatchOverridenProperties.kt") + public void testCantChangePropertyTypeToMatchOverridenProperties() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt"); + } + + @TestMetadata("beforeChangeOverriddenPropertyType1.kt") + public void testChangeOverriddenPropertyType1() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType1.kt"); + } + + @TestMetadata("beforeChangeOverriddenPropertyType2.kt") + public void testChangeOverriddenPropertyType2() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType2.kt"); } @TestMetadata("beforeChangeOverridingPropertyTypeToFunctionType.kt") From 16d9abf5466979d7f0a5c5824ac560e80e95e2c0 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 15 May 2013 23:02:36 +0200 Subject: [PATCH 63/92] QuickFix: change type of overridden function to type of overridding function --- .../quickfix/ChangeFunctionReturnTypeFix.java | 51 +++++++++++++++---- ...terChangeReturnTypeOfOverriddenFunction.kt | 12 +++++ ...antChangeReturnTypeOfOverriddenFunction.kt | 13 +++++ ...oreChangeReturnTypeOfOverriddenFunction.kt | 12 +++++ .../quickfix/QuickFixTestGenerated.java | 10 ++++ 5 files changed, 89 insertions(+), 9 deletions(-) create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeReturnTypeOfOverriddenFunction.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeReturnTypeOfOverriddenFunction.kt create mode 100644 idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeReturnTypeOfOverriddenFunction.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java index b9483a3e818..c9a974790aa 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java @@ -28,6 +28,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters3; import org.jetbrains.jet.lang.psi.*; @@ -38,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil; @@ -45,6 +47,9 @@ import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction; import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache; import org.jetbrains.jet.renderer.DescriptorRenderer; +import java.util.LinkedList; +import java.util.List; + public class ChangeFunctionReturnTypeFix extends JetIntentionAction { private final JetType type; private final String renderedType; @@ -175,7 +180,8 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction JetBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpression.class); assert expression != null : "COMPARE_TO_TYPE_MISMATCH reported on element that is not within any expression"; BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) expression.getContainingFile()).getBindingContext(); - ResolvedCall resolvedCall = context.get(BindingContext.RESOLVED_CALL, expression.getOperationReference()); + ResolvedCall resolvedCall = context.get(BindingContext.RESOLVED_CALL, + expression.getOperationReference()); if (resolvedCall == null) return null; PsiElement compareTo = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); if (!(compareTo instanceof JetFunction)) return null; @@ -185,16 +191,43 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction } @NotNull - public static JetSingleIntentionActionFactory createFactoryForReturnTypeMismatchOnOverride() { - return new JetSingleIntentionActionFactory() { - @Nullable + public static JetIntentionActionsFactory createFactoryForReturnTypeMismatchOnOverride() { + return new JetIntentionActionsFactory() { + @NotNull @Override - public IntentionAction createAction(Diagnostic diagnostic) { + public List createActions(Diagnostic diagnostic) { + List actions = new LinkedList(); + JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class); - if (function == null) return null; - BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(function); - JetType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, function); - return matchingReturnType == null ? null : new ChangeFunctionReturnTypeFix(function, matchingReturnType); + if (function != null) { + BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(function); + JetType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, function); + if (matchingReturnType != null) { + actions.add(new ChangeFunctionReturnTypeFix(function, matchingReturnType)); + } + + SimpleFunctionDescriptor descriptor = context.get(BindingContext.FUNCTION, function); + if (descriptor == null) return actions; + JetType functionType = descriptor.getReturnType(); + if (functionType == null) return actions; + + List overriddenMismatchingFunctions = new LinkedList(); + for (FunctionDescriptor overriddenFunction: descriptor.getOverriddenDescriptors()) { + JetType overriddenFunctionType = overriddenFunction.getReturnType(); + if (overriddenFunctionType == null) continue; + if (!JetTypeChecker.INSTANCE.isSubtypeOf(functionType, overriddenFunctionType)) { + overriddenMismatchingFunctions.add(overriddenFunction); + } + } + + if (overriddenMismatchingFunctions.size() == 1) { + PsiElement overriddenFunction = BindingContextUtils.descriptorToDeclaration(context, overriddenMismatchingFunctions.get(0)); + if (overriddenFunction instanceof JetFunction) { + actions.add(new ChangeFunctionReturnTypeFix((JetFunction) overriddenFunction, functionType)); + } + } + } + return actions; } }; } diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeReturnTypeOfOverriddenFunction.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeReturnTypeOfOverriddenFunction.kt new file mode 100644 index 00000000000..0efefb16139 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/afterChangeReturnTypeOfOverriddenFunction.kt @@ -0,0 +1,12 @@ +// "Change 'A.foo' function return type to 'Long'" "true" +trait A { + fun foo(): Long +} + +trait B { + fun foo(): Number +} + +trait C : A, B { + override fun foo(): Long +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeReturnTypeOfOverriddenFunction.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeReturnTypeOfOverriddenFunction.kt new file mode 100644 index 00000000000..302ed8d5be4 --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeReturnTypeOfOverriddenFunction.kt @@ -0,0 +1,13 @@ +// "Change 'A.foo' function return type to 'Long'" "false" +// ERROR: Return type is 'jet.Long', which is not a subtype of overridden
internal abstract fun foo(): jet.Int defined in A +trait A { + fun foo(): Int +} + +trait B { + fun foo(): String +} + +trait C : A, B { + override fun foo(): Long +} \ No newline at end of file diff --git a/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeReturnTypeOfOverriddenFunction.kt b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeReturnTypeOfOverriddenFunction.kt new file mode 100644 index 00000000000..a8ccbc2551c --- /dev/null +++ b/idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeReturnTypeOfOverriddenFunction.kt @@ -0,0 +1,12 @@ +// "Change 'A.foo' function return type to 'Long'" "true" +trait A { + fun foo(): Int +} + +trait B { + fun foo(): Number +} + +trait C : A, B { + override fun foo(): Long +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 9b22cc5d85a..8e766d00b3a 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1033,6 +1033,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangePropertyTypeToMatchOverridenProperties.kt"); } + @TestMetadata("beforeCantChangeReturnTypeOfOverriddenFunction.kt") + public void testCantChangeReturnTypeOfOverriddenFunction() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeCantChangeReturnTypeOfOverriddenFunction.kt"); + } + @TestMetadata("beforeChangeOverriddenPropertyType1.kt") public void testChangeOverriddenPropertyType1() throws Exception { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverriddenPropertyType1.kt"); @@ -1048,6 +1053,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeOverridingPropertyTypeToFunctionType.kt"); } + @TestMetadata("beforeChangeReturnTypeOfOverriddenFunction.kt") + public void testChangeReturnTypeOfOverriddenFunction() throws Exception { + doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforeChangeReturnTypeOfOverriddenFunction.kt"); + } + @TestMetadata("beforePropertyReturnTypeMismatchOnOverride.kt") public void testPropertyReturnTypeMismatchOnOverride() throws Exception { doTest("idea/testData/quickfix/override/typeMismatchOnOverride/beforePropertyReturnTypeMismatchOnOverride.kt"); From 0a541373a504da242f484aebe0ccc5369d2c00b9 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 15 May 2013 23:48:49 +0200 Subject: [PATCH 64/92] QuickFix: change property type to match expression returned by getter --- .../ChangeFunctionLiteralReturnTypeFix.java | 2 +- .../plugin/quickfix/ChangeVariableTypeFix.java | 15 +++++++++++++++ .../QuickFixFactoryForTypeMismatchError.java | 10 +++++++--- .../jet/plugin/quickfix/QuickFixUtil.java | 8 ++++---- .../afterPropertyGetterInitializerTypeMismatch.kt | 6 ++++++ ...beforePropertyGetterInitializerTypeMismatch.kt | 6 ++++++ .../plugin/quickfix/QuickFixTestGenerated.java | 5 +++++ 7 files changed, 44 insertions(+), 8 deletions(-) create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterPropertyGetterInitializerTypeMismatch.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforePropertyGetterInitializerTypeMismatch.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java index b257b99cfdc..c7ac17cd164 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java @@ -85,7 +85,7 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction typeWhiteSpaceAndColon = JetPsiFactory.createTypeWhiteSpaceAndColon(project, renderedType); element.addRangeAfter(typeWhiteSpaceAndColon.first, typeWhiteSpaceAndColon.second, nameIdentifier); + + if (element instanceof JetProperty) { + JetPropertyAccessor getter = ((JetProperty) element).getGetter(); + JetTypeReference getterReturnTypeRef = getter == null ? null : getter.getReturnTypeReference(); + if (getterReturnTypeRef != null) { + getterReturnTypeRef.replace(JetPsiFactory.createType(project, renderedType)); + } + + JetPropertyAccessor setter = ((JetProperty) element).getSetter(); + JetParameter setterParameter = setter == null ? null : setter.getParameter(); + JetTypeReference setterParameterTypeRef = setterParameter == null ? null : setterParameter.getTypeReference(); + if (setterParameterTypeRef != null) { + setterParameterTypeRef.replace(JetPsiFactory.createType(project, renderedType)); + } + } } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java index 70c1c6632b0..ec304583cb9 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -56,13 +56,17 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF // Property initializer type mismatch property type: JetProperty property = PsiTreeUtil.getParentOfType(expression, JetProperty.class); - if (property != null && QuickFixUtil.canEvaluateTo(property.getInitializer(), expression)) { - actions.add(new ChangeVariableTypeFix(property, expressionType)); + if (property != null) { + JetPropertyAccessor getter = property.getGetter(); + if (QuickFixUtil.canEvaluateTo(property.getInitializer(), expression) || + (getter != null && QuickFixUtil.canFunctionOrGetterReturnExpression(property.getGetter(), expression))) { + actions.add(new ChangeVariableTypeFix(property, expressionType)); + } } // Mismatch in returned expression: JetFunction function = PsiTreeUtil.getParentOfType(expression, JetFunction.class, true); - if (function != null && QuickFixUtil.canFunctionReturnExpression(function, expression)) { + if (function != null && QuickFixUtil.canFunctionOrGetterReturnExpression(function, expression)) { actions.add(new ChangeFunctionReturnTypeFix(function, expressionType)); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index a7217ba7006..c7d003be348 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -175,14 +175,14 @@ public class QuickFixUtil { return true; } - public static boolean canFunctionReturnExpression(@NotNull JetFunction function, @NotNull JetExpression expression) { - if (function instanceof JetFunctionLiteral) { - JetBlockExpression functionLiteralBody = ((JetFunctionLiteral) function).getBodyExpression(); + public static boolean canFunctionOrGetterReturnExpression(@NotNull JetDeclaration functionOrGetter, @NotNull JetExpression expression) { + if (functionOrGetter instanceof JetFunctionLiteral) { + JetBlockExpression functionLiteralBody = ((JetFunctionLiteral) functionOrGetter).getBodyExpression(); PsiElement returnedElement = functionLiteralBody == null ? null : functionLiteralBody.getLastChild(); return returnedElement instanceof JetExpression && canEvaluateTo((JetExpression) returnedElement, expression); } else { - if (function instanceof JetWithExpressionInitializer && canEvaluateTo(((JetWithExpressionInitializer) function).getInitializer(), expression)) { + if (functionOrGetter instanceof JetWithExpressionInitializer && canEvaluateTo(((JetWithExpressionInitializer) functionOrGetter).getInitializer(), expression)) { return true; } JetReturnExpression returnExpression = PsiTreeUtil.getParentOfType(expression, JetReturnExpression.class); diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterPropertyGetterInitializerTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterPropertyGetterInitializerTypeMismatch.kt new file mode 100644 index 00000000000..e22fc7027ef --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/afterPropertyGetterInitializerTypeMismatch.kt @@ -0,0 +1,6 @@ +// "Change 'A.x' type to '() -> Int'" "true" +class A { + var x: () -> Int + get(): () -> Int = if (true) { {42} } else { {24} } + set(i: () -> Int) {} +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforePropertyGetterInitializerTypeMismatch.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforePropertyGetterInitializerTypeMismatch.kt new file mode 100644 index 00000000000..c9196877276 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforePropertyGetterInitializerTypeMismatch.kt @@ -0,0 +1,6 @@ +// "Change 'A.x' type to '() -> Int'" "true" +class A { + var x: Int + get(): Int = if (true) { {42} } else { {24} } + set(i: Int) {} +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 8e766d00b3a..66801905864 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1514,6 +1514,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt"); } + @TestMetadata("beforePropertyGetterInitializerTypeMismatch.kt") + public void testPropertyGetterInitializerTypeMismatch() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforePropertyGetterInitializerTypeMismatch.kt"); + } + @TestMetadata("beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt") public void testReturnedExpresionCantEvaluateToExpresionThatTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeReturnedExpresionCantEvaluateToExpresionThatTypeMismatch.kt"); From c6a378f4fbfd5ee3a878ea091eb8fc9f58581fbf Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Thu, 16 May 2013 00:44:23 +0200 Subject: [PATCH 65/92] Rename directory with tests --- .../afterChangeFunctionParameterType1.kt | 0 .../afterChangeFunctionParameterType2.kt | 0 .../afterChangeFunctionParameterType3.kt | 0 .../beforeChangeFunctionParameterType1.kt | 0 .../beforeChangeFunctionParameterType2.kt | 0 .../beforeChangeFunctionParameterType3.kt | 0 .../beforeChangeFunctionParameterType4.kt | 0 .../beforeChangeFunctionParameterType5.kt | 0 .../quickfix/QuickFixTestGenerated.java | 22 +++++++++---------- 9 files changed, 11 insertions(+), 11 deletions(-) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/afterChangeFunctionParameterType1.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/afterChangeFunctionParameterType2.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/afterChangeFunctionParameterType3.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/beforeChangeFunctionParameterType1.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/beforeChangeFunctionParameterType2.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/beforeChangeFunctionParameterType3.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/beforeChangeFunctionParameterType4.kt (100%) rename idea/testData/quickfix/typeMismatch/{functionParameterTypeMismatch => parameterTypeMismatch}/beforeChangeFunctionParameterType5.kt (100%) diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType1.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType1.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType1.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType2.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType2.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType2.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType3.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/afterChangeFunctionParameterType3.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType3.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType1.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType1.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType2.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType2.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType3.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType3.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType4.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType4.kt diff --git a/idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType5.kt similarity index 100% rename from idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt rename to idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType5.kt diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 66801905864..5ad88c7a44e 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1275,7 +1275,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } @TestMetadata("idea/testData/quickfix/typeMismatch") - @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.FixOverloadedOperator.class, TypeMismatch.FunctionParameterTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) + @InnerTestClasses({TypeMismatch.Casts.class, TypeMismatch.ComponentFunctionReturnTypeMismatch.class, TypeMismatch.FixOverloadedOperator.class, TypeMismatch.ParameterTypeMismatch.class, TypeMismatch.TypeMismatchOnReturnedExpression.class}) public static class TypeMismatch extends AbstractQuickFixTest { public void testAllFilesPresentInTypeMismatch() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); @@ -1445,35 +1445,35 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } - @TestMetadata("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch") - public static class FunctionParameterTypeMismatch extends AbstractQuickFixTest { - public void testAllFilesPresentInFunctionParameterTypeMismatch() throws Exception { - JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); + @TestMetadata("idea/testData/quickfix/typeMismatch/parameterTypeMismatch") + public static class ParameterTypeMismatch extends AbstractQuickFixTest { + public void testAllFilesPresentInParameterTypeMismatch() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/quickfix/typeMismatch/parameterTypeMismatch"), Pattern.compile("^before(\\w+)\\.kt$"), true); } @TestMetadata("beforeChangeFunctionParameterType1.kt") public void testChangeFunctionParameterType1() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType1.kt"); + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType1.kt"); } @TestMetadata("beforeChangeFunctionParameterType2.kt") public void testChangeFunctionParameterType2() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType2.kt"); + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType2.kt"); } @TestMetadata("beforeChangeFunctionParameterType3.kt") public void testChangeFunctionParameterType3() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType3.kt"); + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType3.kt"); } @TestMetadata("beforeChangeFunctionParameterType4.kt") public void testChangeFunctionParameterType4() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType4.kt"); + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType4.kt"); } @TestMetadata("beforeChangeFunctionParameterType5.kt") public void testChangeFunctionParameterType5() throws Exception { - doTest("idea/testData/quickfix/typeMismatch/functionParameterTypeMismatch/beforeChangeFunctionParameterType5.kt"); + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType5.kt"); } } @@ -1557,7 +1557,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { suite.addTestSuite(Casts.class); suite.addTestSuite(ComponentFunctionReturnTypeMismatch.class); suite.addTestSuite(FixOverloadedOperator.class); - suite.addTestSuite(FunctionParameterTypeMismatch.class); + suite.addTestSuite(ParameterTypeMismatch.class); suite.addTestSuite(TypeMismatchOnReturnedExpression.class); return suite; } From 2a97617880e0b164017f64ce887bfa3faa1a210e Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Thu, 16 May 2013 00:43:26 +0200 Subject: [PATCH 66/92] QuickFix: change type of constructor parameter to match value argument in invocation --- .../jetbrains/jet/plugin/JetBundle.properties | 1 + .../ChangeFunctionLiteralReturnTypeFix.java | 4 ++-- ...peFix.java => ChangeParameterTypeFix.java} | 20 +++++++++++-------- .../QuickFixFactoryForTypeMismatchError.java | 12 +++++------ .../jet/plugin/quickfix/QuickFixUtil.java | 19 ++++++++++-------- ...erChangePrimaryConstructorParameterType.kt | 5 +++++ ...reChangePrimaryConstructorParameterType.kt | 5 +++++ .../quickfix/QuickFixTestGenerated.java | 5 +++++ 8 files changed, 47 insertions(+), 24 deletions(-) rename idea/src/org/jetbrains/jet/plugin/quickfix/{ChangeFunctionParameterTypeFix.java => ChangeParameterTypeFix.java} (67%) create mode 100644 idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangePrimaryConstructorParameterType.kt create mode 100644 idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangePrimaryConstructorParameterType.kt diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index 6f7ebde6deb..a68d3edbb91 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -64,6 +64,7 @@ remove.function.return.type=Remove explicitly specified return type in ''{0}'' f remove.no.name.function.return.type=Remove explicitly specified function return type change.element.type=Change ''{0}'' type to ''{1}'' change.function.parameter.type=Change parameter ''{0}'' type of function ''{1}'' to ''{2}'' +change.primary.constructor.parameter.type=Change parameter ''{0}'' type of primary constructor of class ''{1}'' to ''{2}'' change.type=Change type from ''{0}'' to ''{1}'' change.type.family=Change Type add.parameters.to.function=Add parameter{0} to function ''{1}'' diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java index c7ac17cd164..3027cba79c4 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java @@ -74,12 +74,12 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction { +public class ChangeParameterTypeFix extends JetIntentionAction { private final String renderedType; - private final String containingFunctionName; + private final String containingDeclarationName; + private final boolean isPrimaryConstructorParameter; - public ChangeFunctionParameterTypeFix(@NotNull JetParameter element, @NotNull JetType type) { + public ChangeParameterTypeFix(@NotNull JetParameter element, @NotNull JetType type) { super(element); renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); - JetFunction function = PsiTreeUtil.getParentOfType(element, JetFunction.class); - FqName functionFQName = function == null ? null : JetPsiUtil.getFQName(function); - containingFunctionName = functionFQName == null ? null : functionFQName.getFqName(); + JetNamedDeclaration declaration = PsiTreeUtil.getParentOfType(element, JetNamedDeclaration.class); + isPrimaryConstructorParameter = declaration instanceof JetClass; + FqName declarationFQName = declaration == null ? null : JetPsiUtil.getFQName(declaration); + containingDeclarationName = declarationFQName == null ? null : declarationFQName.asString(); } @Override public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { - return super.isAvailable(project, editor, file) && containingFunctionName != null; + return super.isAvailable(project, editor, file) && containingDeclarationName != null; } @NotNull @Override public String getText() { - return JetBundle.message("change.function.parameter.type", element.getName(), containingFunctionName, renderedType); + return isPrimaryConstructorParameter ? + JetBundle.message("change.primary.constructor.parameter.type", element.getName(), containingDeclarationName, renderedType) : + JetBundle.message("change.function.parameter.type", element.getName(), containingDeclarationName, renderedType); } @NotNull diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java index ec304583cb9..9eb2dd5314b 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixFactoryForTypeMismatchError.java @@ -89,7 +89,7 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getResultingDescriptor()); if (declaration instanceof JetFunction) { JetParameter binaryOperatorParameter = ((JetFunction) declaration).getValueParameterList().getParameters().get(0); - actions.add(new ChangeFunctionParameterTypeFix(binaryOperatorParameter, expressionType)); + actions.add(new ChangeParameterTypeFix(binaryOperatorParameter, expressionType)); } } } @@ -113,20 +113,20 @@ public class QuickFixFactoryForTypeMismatchError implements JetIntentionActionsF QuickFixUtil.getParentElementOfType(diagnostic, JetFunctionLiteralExpression.class); if (functionLiteralExpression != null && functionLiteralExpression.getBodyExpression() == expression) { JetParameter correspondingParameter = - QuickFixUtil.getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(functionLiteralExpression); + QuickFixUtil.getParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(functionLiteralExpression); JetType functionLiteralExpressionType = context.get(BindingContext.EXPRESSION_TYPE, functionLiteralExpression); if (correspondingParameter != null && functionLiteralExpressionType != null) { - actions.add(new ChangeFunctionParameterTypeFix(correspondingParameter, functionLiteralExpressionType)); + actions.add(new ChangeParameterTypeFix(correspondingParameter, functionLiteralExpressionType)); } } // 2) When an argument is passed inside value argument list: else { JetValueArgument valueArgument = QuickFixUtil.getParentElementOfType(diagnostic, JetValueArgument.class); - if (valueArgument != null && valueArgument.getArgumentExpression() == expression) { - JetParameter correspondingParameter = QuickFixUtil.getFunctionParameterCorrespondingToValueArgumentPassedInCall(valueArgument); + if (valueArgument != null && QuickFixUtil.canEvaluateTo(valueArgument.getArgumentExpression(), expression)) { + JetParameter correspondingParameter = QuickFixUtil.getParameterCorrespondingToValueArgumentPassedInCall(valueArgument); JetType valueArgumentType = context.get(BindingContext.EXPRESSION_TYPE, valueArgument.getArgumentExpression()); if (correspondingParameter != null && valueArgumentType != null) { - actions.add(new ChangeFunctionParameterTypeFix(correspondingParameter, valueArgumentType)); + actions.add(new ChangeParameterTypeFix(correspondingParameter, valueArgumentType)); } } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index c7d003be348..11380a56cc4 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -95,30 +95,33 @@ public class QuickFixUtil { } @Nullable - public static JetParameterList getParameterListOfCalledFunction(@NotNull JetCallExpression callExpression) { + public static JetParameterList getParameterListOfCallee(@NotNull JetCallExpression callExpression) { BindingContext context = AnalyzerFacadeWithCache.analyzeFileWithCache((JetFile) callExpression.getContainingFile()).getBindingContext(); ResolvedCall resolvedCall = context.get(BindingContext.RESOLVED_CALL, callExpression.getCalleeExpression()); if (resolvedCall == null) return null; - PsiElement functionDeclaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); - if (functionDeclaration instanceof JetFunction) { - return ((JetFunction) functionDeclaration).getValueParameterList(); + PsiElement declaration = BindingContextUtils.descriptorToDeclaration(context, resolvedCall.getCandidateDescriptor()); + if (declaration instanceof JetFunction) { + return ((JetFunction) declaration).getValueParameterList(); + } + if (declaration instanceof JetClass) { + return ((JetClass) declaration).getPrimaryConstructorParameterList(); } return null; } @Nullable - public static JetParameter getFunctionParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(@NotNull JetFunctionLiteralExpression functionLiteralExpression) { + public static JetParameter getParameterCorrespondingToFunctionLiteralPassedOutsideArgumentList(@NotNull JetFunctionLiteralExpression functionLiteralExpression) { if (!(functionLiteralExpression.getParent() instanceof JetCallExpression)) { return null; } JetCallExpression callExpression = (JetCallExpression) functionLiteralExpression.getParent(); - JetParameterList parameterList = getParameterListOfCalledFunction(callExpression); + JetParameterList parameterList = getParameterListOfCallee(callExpression); if (parameterList == null) return null; return parameterList.getParameters().get(parameterList.getParameters().size() - 1); } @Nullable - public static JetParameter getFunctionParameterCorrespondingToValueArgumentPassedInCall(@NotNull JetValueArgument valueArgument) { + public static JetParameter getParameterCorrespondingToValueArgumentPassedInCall(@NotNull JetValueArgument valueArgument) { if (!(valueArgument.getParent() instanceof JetValueArgumentList)) { return null; } @@ -127,7 +130,7 @@ public class QuickFixUtil { return null; } JetCallExpression callExpression = (JetCallExpression) valueArgumentList.getParent(); - JetParameterList parameterList = getParameterListOfCalledFunction(callExpression); + JetParameterList parameterList = getParameterListOfCallee(callExpression); if (parameterList == null) return null; int position = valueArgumentList.getArguments().indexOf(valueArgument); if (position == -1) return null; diff --git a/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangePrimaryConstructorParameterType.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangePrimaryConstructorParameterType.kt new file mode 100644 index 00000000000..9acd1ad0389 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangePrimaryConstructorParameterType.kt @@ -0,0 +1,5 @@ +// "Change parameter 'a' type of primary constructor of class 'B' to 'String'" "true" +class B(val a: String) +fun foo() { + B(if (true) "" else "") +} diff --git a/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangePrimaryConstructorParameterType.kt b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangePrimaryConstructorParameterType.kt new file mode 100644 index 00000000000..7e39c54a4a1 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangePrimaryConstructorParameterType.kt @@ -0,0 +1,5 @@ +// "Change parameter 'a' type of primary constructor of class 'B' to 'String'" "true" +class B(val a: Int) +fun foo() { + B(if (true) "" else "") +} diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index 5ad88c7a44e..fe3b3c67a02 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1476,6 +1476,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType5.kt"); } + @TestMetadata("beforeChangePrimaryConstructorParameterType.kt") + public void testChangePrimaryConstructorParameterType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangePrimaryConstructorParameterType.kt"); + } + } @TestMetadata("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression") From 4bf7151e473cf3cf78c89379943b895b936703e9 Mon Sep 17 00:00:00 2001 From: Wojciech Lopata Date: Wed, 29 May 2013 13:52:27 +0200 Subject: [PATCH 67/92] Make "type mismatch" quickfixes not available in case of error types --- .../plugin/quickfix/ChangeFunctionReturnTypeFix.java | 7 +++++++ .../jet/plugin/quickfix/ChangeVariableTypeFix.java | 9 +++++++++ ...eforeDontChangeOverriddenPropertyTypeToErrorType.kt | 10 ++++++++++ .../beforeDontChangeFunctionReturnTypeToErrorType.kt | 6 ++++++ .../jet/plugin/quickfix/QuickFixTestGenerated.java | 10 ++++++++++ 5 files changed, 42 insertions(+) create mode 100644 idea/testData/quickfix/typeMismatch/beforeDontChangeOverriddenPropertyTypeToErrorType.kt create mode 100644 idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeDontChangeFunctionReturnTypeToErrorType.kt diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java index c9a974790aa..cf22d69bf9c 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionReturnTypeFix.java @@ -22,6 +22,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiErrorElement; +import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; @@ -38,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -96,6 +98,11 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction return JetBundle.message("change.type.family"); } + @Override + public boolean isAvailable(@NotNull Project project, @Nullable Editor editor, @Nullable PsiFile file) { + return super.isAvailable(project, editor, file) && !ErrorUtils.containsErrorType(type); + } + @Override public void invoke(@NotNull Project project, @Nullable Editor editor, @Nullable JetFile file) throws IncorrectOperationException { if (changeFunctionLiteralReturnTypeFix != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java index c80f8d356dd..bcb408900ba 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeVariableTypeFix.java @@ -21,6 +21,7 @@ import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -32,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.plugin.JetBundle; @@ -45,10 +47,12 @@ import java.util.List; public class ChangeVariableTypeFix extends JetIntentionAction { private final String renderedType; + private final JetType type; public ChangeVariableTypeFix(@NotNull JetVariableDeclaration element, @NotNull JetType type) { super(element); renderedType = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(type); + this.type = type; } @NotNull @@ -67,6 +71,11 @@ public class ChangeVariableTypeFix extends JetIntentionAction [ERROR : Ay]'" "false" +// ACTION: Change 'A.x' type to '(Int) -> Int' +// ERROR: Return type is '(jet.Int) → jet.Int', which is not a subtype of overridden
internal abstract val x: (jet.String) → [ERROR : Ay] defined in A +// ERROR: Unresolved reference: Ay +trait A { + val x: (String) -> Ay +} +trait B : A { + override val x: (Int) -> Int +} \ No newline at end of file diff --git a/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeDontChangeFunctionReturnTypeToErrorType.kt b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeDontChangeFunctionReturnTypeToErrorType.kt new file mode 100644 index 00000000000..ff1d6c75cf7 --- /dev/null +++ b/idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeDontChangeFunctionReturnTypeToErrorType.kt @@ -0,0 +1,6 @@ +// "Change 'foo' function return type to '([ERROR : NoSuchType]) -> Int'" "false" +// ERROR: Type mismatch.
Required:jet.Int
Found:([ERROR : NoSuchType]) → jet.Int
+// ERROR: Unresolved reference: NoSuchType +fun foo(): Int { + return { (x: NoSuchType) -> 42 } +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java index fe3b3c67a02..f4226698736 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/QuickFixTestGenerated.java @@ -1306,6 +1306,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/beforeCompareToTypeMismatch.kt"); } + @TestMetadata("beforeDontChangeOverriddenPropertyTypeToErrorType.kt") + public void testDontChangeOverriddenPropertyTypeToErrorType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/beforeDontChangeOverriddenPropertyTypeToErrorType.kt"); + } + @TestMetadata("beforeExpectedParameterTypeMismatch.kt") public void testExpectedParameterTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/beforeExpectedParameterTypeMismatch.kt"); @@ -1514,6 +1519,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeChangeFunctionReturnTypeToMatchReturnTypeOfReturnedLiteral.kt"); } + @TestMetadata("beforeDontChangeFunctionReturnTypeToErrorType.kt") + public void testDontChangeFunctionReturnTypeToErrorType() throws Exception { + doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeDontChangeFunctionReturnTypeToErrorType.kt"); + } + @TestMetadata("beforeExpectedTypeMismatch.kt") public void testExpectedTypeMismatch() throws Exception { doTest("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression/beforeExpectedTypeMismatch.kt"); From 6465abe7eb02304bc9a4698031bb9c45a3095391 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 29 May 2013 21:07:54 +0400 Subject: [PATCH 68/92] Do not fail on circular dependencies + better message --- .../jet/jps/build/KotlinBuilder.java | 20 ++++++++++++++++--- .../jet/jps/build/KotlinJpsBuildTestCase.java | 4 ++++ .../kotlinProject.iml | 14 +++++++++++++ .../kotlinProject.ipr | 15 ++++++++++++++ .../module2/module2.iml | 14 +++++++++++++ .../module2/src/JSecond.java | 5 +++++ .../src/JFirst.java | 11 ++++++++++ 7 files changed, 80 insertions(+), 3 deletions(-) create mode 100644 jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.iml create mode 100644 jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.ipr create mode 100644 jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/module2.iml create mode 100644 jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/src/JSecond.java create mode 100644 jps-plugin/testData/CircularDependenciesNoKotlinFiles/src/JFirst.java diff --git a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java index 2f0eb7bb58f..0d88d6e635b 100644 --- a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java +++ b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilder.java @@ -16,6 +16,8 @@ package org.jetbrains.jet.jps.build; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation; @@ -29,19 +31,27 @@ import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor; import org.jetbrains.jps.incremental.*; import org.jetbrains.jps.incremental.messages.BuildMessage; import org.jetbrains.jps.incremental.messages.CompilerMessage; +import org.jetbrains.jps.model.module.JpsModule; import java.io.File; import java.io.IOException; import java.util.Collection; import java.util.List; -import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.ERROR; import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.EXCEPTION; +import static org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity.WARNING; public class KotlinBuilder extends ModuleLevelBuilder { private static final String KOTLIN_BUILDER_NAME = "Kotlin Builder"; + private static final Function MODULE_NAME = new Function() { + @Override + public String fun(JpsModule module) { + return module.getName(); + } + }; + protected KotlinBuilder() { super(BuilderCategory.SOURCE_PROCESSOR); } @@ -63,10 +73,14 @@ public class KotlinBuilder extends ModuleLevelBuilder { MessageCollector messageCollector = new MessageCollectorAdapter(context); if (chunk.getModules().size() > 1) { + // We do not support circular dependencies, but if they are present, we should not break the build, + // so we simply yield a warning and report NOTHING_DONE messageCollector.report( - ERROR, "Circular dependencies are not supported: " + chunk.getModules(), + WARNING, "Circular dependencies are not supported. " + + "The following modules depend on each other: " + StringUtil.join(chunk.getModules(), MODULE_NAME, ", ") + ". " + + "Kotlin is not compiled for these modules", CompilerMessageLocation.NO_LOCATION); - return ExitCode.ABORT; + return ExitCode.NOTHING_DONE; } ModuleBuildTarget representativeTarget = chunk.representativeTarget(); diff --git a/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTestCase.java b/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTestCase.java index 7461afc3328..72c20c11c83 100644 --- a/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTestCase.java +++ b/jps-plugin/test/org/jetbrains/jet/jps/build/KotlinJpsBuildTestCase.java @@ -82,6 +82,10 @@ public class KotlinJpsBuildTestCase extends AbstractKotlinJpsBuildTestCase { doTestWithRuntime(); } + public void testCircularDependenciesNoKotlinFiles() { + doTest(); + } + public void testTestDependencyLibrary() throws Throwable { initProject(); addKotlinRuntimeDependency(JpsJavaDependencyScope.TEST); diff --git a/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.iml b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.iml new file mode 100644 index 00000000000..5559c7ad919 --- /dev/null +++ b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.ipr b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.ipr new file mode 100644 index 00000000000..809737b0b76 --- /dev/null +++ b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/kotlinProject.ipr @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + diff --git a/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/module2.iml b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/module2.iml new file mode 100644 index 00000000000..eace69878a2 --- /dev/null +++ b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/module2.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/src/JSecond.java b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/src/JSecond.java new file mode 100644 index 00000000000..e034bf38792 --- /dev/null +++ b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/module2/src/JSecond.java @@ -0,0 +1,5 @@ +public class JSecond { + public static void main(String[] args) { + new JFirst().foo(); + } +} diff --git a/jps-plugin/testData/CircularDependenciesNoKotlinFiles/src/JFirst.java b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/src/JFirst.java new file mode 100644 index 00000000000..12140d2a7e4 --- /dev/null +++ b/jps-plugin/testData/CircularDependenciesNoKotlinFiles/src/JFirst.java @@ -0,0 +1,11 @@ +public class JFirst { + JSecond s = null; + + public void foo() { + + } + + public static void main(String[] args) { + System.out.println(1); + } +} \ No newline at end of file From 7ff1885e8ea65c95ab42cc2e5721f2b6ef4ba9ce Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 29 May 2013 21:28:26 +0400 Subject: [PATCH 69/92] The error message now tells the user about jps.kotlin.home For TeamCity users --- compiler/util/src/org/jetbrains/jet/utils/PathUtil.java | 4 +++- .../jetbrains/jet/compiler/runner/CompilerEnvironment.java | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java index cbafebff153..0c7f7924327 100644 --- a/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java +++ b/compiler/util/src/org/jetbrains/jet/utils/PathUtil.java @@ -27,6 +27,8 @@ import java.io.File; public class PathUtil { + public static final String JPS_KOTLIN_HOME_PROPERTY = "jps.kotlin.home"; + public static final String JS_LIB_JAR_NAME = "kotlin-jslib.jar"; public static final String JS_LIB_JS_NAME = "kotlinEcma3.js"; public static final String JDK_ANNOTATIONS_JAR = "kotlin-jdk-annotations.jar"; @@ -46,7 +48,7 @@ public class PathUtil { public static KotlinPaths getKotlinPathsForJpsPlugin() { // When JPS is run on TeamCity, it can not rely on Kotlin plugin layout, // so the path to Kotlin is specified in a system property - String jpsKotlinHome = System.getProperty("jps.kotlin.home"); + String jpsKotlinHome = System.getProperty(JPS_KOTLIN_HOME_PROPERTY); if (jpsKotlinHome != null) { return new KotlinPathsFromHomeDir(new File(jpsKotlinHome)); } diff --git a/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerEnvironment.java b/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerEnvironment.java index c2bc4431392..a633c4f5f24 100644 --- a/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerEnvironment.java +++ b/ide-compiler-runner/src/org/jetbrains/jet/compiler/runner/CompilerEnvironment.java @@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.utils.KotlinPaths; +import org.jetbrains.jet.utils.PathUtil; import java.io.File; @@ -61,7 +62,8 @@ public final class CompilerEnvironment { messageCollector.report(ERROR, "[Internal Error] No output directory", NO_LOCATION); } if (!kotlinPaths.getHomePath().exists()) { - messageCollector.report(ERROR, "Cannot find kotlinc home: " + kotlinPaths.getHomePath() + ". Make sure plugin is properly installed", NO_LOCATION); + messageCollector.report(ERROR, "Cannot find kotlinc home: " + kotlinPaths.getHomePath() + ". Make sure plugin is properly installed, " + + "or specify " + PathUtil.JPS_KOTLIN_HOME_PROPERTY + " system property", NO_LOCATION); } } From b08751f50107ebdcea6fbb2689af7f290ad9200e Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 30 May 2013 12:53:26 +0400 Subject: [PATCH 70/92] Fixed starting in profiler. --- compiler/util/src/org/jetbrains/jet/utils/Profiler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/util/src/org/jetbrains/jet/utils/Profiler.java b/compiler/util/src/org/jetbrains/jet/utils/Profiler.java index 06f4a68dde2..0c4a4f73084 100644 --- a/compiler/util/src/org/jetbrains/jet/utils/Profiler.java +++ b/compiler/util/src/org/jetbrains/jet/utils/Profiler.java @@ -116,7 +116,7 @@ public class Profiler { } public Profiler start() { - if (!paused) { + if (paused) { start = System.nanoTime(); paused = false; } From aa1998fa20ce0e636f3de8c7fd9788a46cb83896 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Wed, 29 May 2013 15:30:03 +0400 Subject: [PATCH 71/92] Check not null annotations for parameters in IdeaJdkAnnotationsReflectedTest --- .../IdeaJdkAnnotationsReflectedTest.java | 57 ++++++++++++++----- 1 file changed, 43 insertions(+), 14 deletions(-) diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java index e1df228e34e..d65fe3c89e0 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java @@ -87,14 +87,14 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { public void visitMethod(PsiMethod method) { super.visitMethod(method); if (method.getReturnType() != null) { // disabled for constructors - check(method, method); + checkAndReport(method); } } @Override public void visitField(PsiField field) { super.visitField(field); - check(field, field); + checkAndReport(field); } @Override @@ -103,22 +103,39 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { PsiMethod method = PsiTreeUtil.getParentOfType(parameter, PsiMethod.class); assert method != null; if (method.getReturnType() != null) { // disabled for constructors - check(parameter, method); + if (!check(parameter, method, AnnotationsKind.KOTLIN_SIGNATURE) && + !check(parameter, parameter, AnnotationsKind.NOT_NULL)) { + declarationsWithMissingAnnotations.add(parameter); + } } } - private void check(@NotNull PsiModifierListOwner ideaOwner, @NotNull PsiModifierListOwner kotlinOwner) { - if (hasAnnotation(ideaFakeAnnotationsManager, ideaOwner, AnnotationUtil.NOT_NULL)) { - boolean kotlinHasNotNull = hasAnnotation(kotlinFakeAnnotationsManager, kotlinOwner, AnnotationUtil.NOT_NULL); - boolean kotlinHasKotlinSignature = hasAnnotation(kotlinFakeAnnotationsManager, kotlinOwner, - JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString()); - if (kotlinOwner == ideaOwner && kotlinHasNotNull || kotlinHasKotlinSignature) { - // good - } - else { - declarationsWithMissingAnnotations.add(kotlinOwner); + private void checkAndReport(@NotNull PsiModifierListOwner annotationOwner) { + if (!check(annotationOwner, annotationOwner, AnnotationsKind.ANY)) { + declarationsWithMissingAnnotations.add(annotationOwner); + } + } + + private boolean check( + @NotNull PsiModifierListOwner ideaOwner, + @NotNull PsiModifierListOwner kotlinOwner, + @NotNull AnnotationsKind annotationsKind + ) + { + return !hasAnnotationInIdea(ideaOwner) || hasAnnotationInKotlin(kotlinOwner, annotationsKind); + } + + private boolean hasAnnotationInIdea(@NotNull PsiModifierListOwner owner) { + return hasAnnotation(ideaFakeAnnotationsManager, owner, AnnotationUtil.NOT_NULL); + } + + private boolean hasAnnotationInKotlin(@NotNull PsiModifierListOwner owner, @NotNull AnnotationsKind annotationsKind) { + for (String name : annotationsKind.annotationNames) { + if (hasAnnotation(kotlinFakeAnnotationsManager, owner, name)) { + return true; } } + return false; } private boolean hasAnnotation( @@ -134,9 +151,21 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { if (!declarationsWithMissingAnnotations.isEmpty()) { StringBuilder builder = new StringBuilder("Annotations missing for JDK items:\n"); for (PsiModifierListOwner declaration : declarationsWithMissingAnnotations) { - builder.append(PsiFormatUtil.getExternalName(declaration)).append("\n"); + builder.append(PsiFormatUtil.getExternalName(declaration) + " " + declaration.getText()).append("\n"); } fail(builder.toString()); } } + + private enum AnnotationsKind { + KOTLIN_SIGNATURE(JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString()), + NOT_NULL(AnnotationUtil.NOT_NULL), + ANY(AnnotationUtil.NOT_NULL, JvmStdlibNames.KOTLIN_SIGNATURE.getFqName().asString()); + + public final String[] annotationNames; + + private AnnotationsKind(@NotNull String... annotationNames) { + this.annotationNames = annotationNames; + } + } } From 7e58d8312194639da1328caa0618206748f86e77 Mon Sep 17 00:00:00 2001 From: Nikita Skvortsov Date: Sun, 26 May 2013 22:06:10 +0400 Subject: [PATCH 72/92] rename module --- libraries/pom.xml | 2 +- .../.gitignore | 0 .../gradle_api_jar/.gitignore | 0 .../gradle_api_jar/README.txt | 14 +-- .../gradle_api_jar/build.gradle | 0 .../gradle/wrapper/gradle-wrapper.jar | Bin .../gradle/wrapper/gradle-wrapper.properties | 0 .../gradle_api_jar/gradlew | 0 .../gradle_api_jar/gradlew.bat | 0 .../gradle_api_jar/pom.xml | 102 +++++++++--------- .../gradle_api_jar/settings.gradle | 0 .../com/google/common/base/annotations.xml | 0 .../com/google/common/io/annotations.xml | 8 +- .../org/apache/commons/io/annotations.xml | 8 +- .../org/gradle/api/annotations.xml | 0 .../org/gradle/api/file/annotations.xml | 0 .../api/initialization/dsl/annotations.xml | 0 .../org/gradle/api/internal/annotations.xml | 0 .../api/internal/project/annotations.xml | 0 .../org/gradle/api/logging/annotations.xml | 8 +- .../org/gradle/api/plugins/annotations.xml | 0 .../org/gradle/api/tasks/annotations.xml | 0 .../gradle/api/tasks/compile/annotations.xml | 0 .../pom.xml | 2 +- .../kotlin/gradle/internal/KotlinSourceSet.kt | 0 .../kotlin/gradle/plugin/KotlinPlugin.kt | 0 .../jetbrains/kotlin/gradle/tasks/Tasks.kt | 0 .../META-INF/gradle-plugins/kotlin.properties | 0 .../kotlin/gradle/KotlinGradlePluginIT.kt | 0 .../resources/testProject/alfa/build.gradle | 0 .../com/google/common/base/annotations.xml | 0 .../alfa/gradle/wrapper/gradle-wrapper.jar | Bin .../gradle/wrapper/gradle-wrapper.properties | 0 .../test/resources/testProject/alfa/gradlew | 0 .../resources/testProject/alfa/gradlew.bat | 0 .../alfa/src/deploy/kotlin/kotlinSrc.kt | 0 .../alfa/src/main/java/demo/Greeter.java | 0 .../alfa/src/main/java/demo/HelloWorld.java | 0 .../alfa/src/main/kotlin/helloWorld.kt | 0 .../testProject/alfa/src/test/kotlin/tests.kt | 0 40 files changed, 72 insertions(+), 72 deletions(-) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/.gitignore (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/.gitignore (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/README.txt (96%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/build.gradle (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/gradle/wrapper/gradle-wrapper.jar (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/gradle/wrapper/gradle-wrapper.properties (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/gradlew (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/gradlew.bat (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/pom.xml (97%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/gradle_api_jar/settings.gradle (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/com/google/common/base/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/com/google/common/io/annotations.xml (97%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/apache/commons/io/annotations.xml (97%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/file/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/internal/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/logging/annotations.xml (97%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/plugins/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/tasks/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/pom.xml (99%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinSourceSet.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/main/resources/META-INF/gradle-plugins/kotlin.properties (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/build.gradle (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/gradlew (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/gradlew.bat (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt (100%) rename libraries/tools/{kotlin-gradle-plugin => kotlin-gradle-plugin-core}/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt (100%) diff --git a/libraries/pom.xml b/libraries/pom.xml index b3e31788884..560c1a1e5e6 100644 --- a/libraries/pom.xml +++ b/libraries/pom.xml @@ -56,7 +56,7 @@ tools/kotlin-compiler tools/kotlin-jdk-annotations tools/runtime - tools/kotlin-gradle-plugin + tools/kotlin-gradle-plugin-core tools/kotlin-maven-plugin tools/kotlin-js-library tools/kotlin-js-tests diff --git a/libraries/tools/kotlin-gradle-plugin/.gitignore b/libraries/tools/kotlin-gradle-plugin-core/.gitignore similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/.gitignore rename to libraries/tools/kotlin-gradle-plugin-core/.gitignore diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/.gitignore b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/.gitignore similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/.gitignore rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/.gitignore diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/README.txt b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/README.txt similarity index 96% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/README.txt rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/README.txt index c9045e657f0..df08dc77e0d 100644 --- a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/README.txt +++ b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/README.txt @@ -1,7 +1,7 @@ -Deploying gradle api to maven - - * gradlew build - -> build/libs/gradle-api-1.4.jar - - * mvn deploy - build/libs/gradle-api-1.4.jar -> http://repository.jetbrains.com/utils +Deploying gradle api to maven + + * gradlew build + -> build/libs/gradle-api-1.4.jar + + * mvn deploy + build/libs/gradle-api-1.4.jar -> http://repository.jetbrains.com/utils diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/build.gradle b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/build.gradle similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/build.gradle rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/build.gradle diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradle/wrapper/gradle-wrapper.jar b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradle/wrapper/gradle-wrapper.jar similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradle/wrapper/gradle-wrapper.jar rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradle/wrapper/gradle-wrapper.jar diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradle/wrapper/gradle-wrapper.properties b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradle/wrapper/gradle-wrapper.properties similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradle/wrapper/gradle-wrapper.properties rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradle/wrapper/gradle-wrapper.properties diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradlew b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradlew similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradlew rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradlew diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradlew.bat b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradlew.bat similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/gradlew.bat rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/gradlew.bat diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/pom.xml b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/pom.xml similarity index 97% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/pom.xml rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/pom.xml index b5e367c2c68..ab208885125 100644 --- a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/pom.xml +++ b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/pom.xml @@ -1,51 +1,51 @@ - - - - 4.0.0 - - 1.4.1 - 3.0.4 - - - org.jetbrains.kotlin - gradle-api - pom - 1.4 - - - - - org.codehaus.mojo - build-helper-maven-plugin - 1.7 - - - attach-artifacts - compile - - attach-artifact - - - - - build/libs/gradle-api-1.4.jar - jar - - - - - - - - - - - - utils - http://repository.jetbrains.com/utils - - - - + + + + 4.0.0 + + 1.4.1 + 3.0.4 + + + org.jetbrains.kotlin + gradle-api + pom + 1.4 + + + + + org.codehaus.mojo + build-helper-maven-plugin + 1.7 + + + attach-artifacts + compile + + attach-artifact + + + + + build/libs/gradle-api-1.4.jar + jar + + + + + + + + + + + + utils + http://repository.jetbrains.com/utils + + + + diff --git a/libraries/tools/kotlin-gradle-plugin/gradle_api_jar/settings.gradle b/libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/settings.gradle similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/gradle_api_jar/settings.gradle rename to libraries/tools/kotlin-gradle-plugin-core/gradle_api_jar/settings.gradle diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/com/google/common/base/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/com/google/common/base/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/com/google/common/io/annotations.xml similarity index 97% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/com/google/common/io/annotations.xml index b7f0b110ddc..64ac65dcca1 100644 --- a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml +++ b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/com/google/common/io/annotations.xml @@ -1,5 +1,5 @@ - - - - + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/apache/commons/io/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/apache/commons/io/annotations.xml similarity index 97% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/apache/commons/io/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/apache/commons/io/annotations.xml index 86f130b880e..0aee42a6e6a 100644 --- a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/apache/commons/io/annotations.xml +++ b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/apache/commons/io/annotations.xml @@ -1,5 +1,5 @@ - - - - + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/file/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/file/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/internal/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/internal/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/logging/annotations.xml similarity index 97% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/logging/annotations.xml index 7ee1ff08665..87c8bc5da18 100644 --- a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml +++ b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/logging/annotations.xml @@ -1,5 +1,5 @@ - - - - + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/plugins/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/plugins/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/tasks/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/tasks/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/pom.xml b/libraries/tools/kotlin-gradle-plugin-core/pom.xml similarity index 99% rename from libraries/tools/kotlin-gradle-plugin/pom.xml rename to libraries/tools/kotlin-gradle-plugin-core/pom.xml index f3602e2ce62..2c558ae18e8 100644 --- a/libraries/tools/kotlin-gradle-plugin/pom.xml +++ b/libraries/tools/kotlin-gradle-plugin-core/pom.xml @@ -16,7 +16,7 @@ ../../pom.xml - kotlin-gradle-plugin + kotlin-gradle-plugin-core jar diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinSourceSet.kt b/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinSourceSet.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinSourceSet.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinSourceSet.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt b/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt b/libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/kotlin.properties b/libraries/tools/kotlin-gradle-plugin-core/src/main/resources/META-INF/gradle-plugins/kotlin.properties similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/kotlin.properties rename to libraries/tools/kotlin-gradle-plugin-core/src/main/resources/META-INF/gradle-plugins/kotlin.properties diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin-core/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradlew similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradlew diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradlew.bat similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/gradlew.bat diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt similarity index 100% rename from libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt rename to libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt From 7e36547b3861bf9e59bd10fe4e87e19d2b95a9b8 Mon Sep 17 00:00:00 2001 From: Nikita Skvortsov Date: Wed, 29 May 2013 19:47:42 +0400 Subject: [PATCH 73/92] Added wrapper module for gradle plugin --- libraries/pom.xml | 1 + .../org/gradle/api/annotations.xml | 18 +++ .../org/gradle/api/file/annotations.xml | 5 + .../api/initialization/dsl/annotations.xml | 7 ++ .../org/gradle/api/internal/annotations.xml | 15 +++ .../api/internal/project/annotations.xml | 5 + .../org/gradle/api/logging/annotations.xml | 5 + .../org/gradle/api/plugins/annotations.xml | 22 ++++ .../org/gradle/api/tasks/annotations.xml | 7 ++ .../gradle/api/tasks/compile/annotations.xml | 5 + libraries/tools/kotlin-gradle-plugin/pom.xml | 107 ++++++++++++++++++ .../ParentLastURLClassLoader.java | 74 ++++++++++++ .../gradle/plugin/KotlinPluginWrapper.kt | 13 +++ .../META-INF/gradle-plugins/kotlin.properties | 2 +- 14 files changed, 285 insertions(+), 1 deletion(-) create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/pom.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java create mode 100644 libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt rename libraries/tools/{kotlin-gradle-plugin-core => kotlin-gradle-plugin}/src/main/resources/META-INF/gradle-plugins/kotlin.properties (85%) diff --git a/libraries/pom.xml b/libraries/pom.xml index 560c1a1e5e6..48652d81263 100644 --- a/libraries/pom.xml +++ b/libraries/pom.xml @@ -56,6 +56,7 @@ tools/kotlin-compiler tools/kotlin-jdk-annotations tools/runtime + tools/kotlin-gradle-plugin tools/kotlin-gradle-plugin-core tools/kotlin-maven-plugin tools/kotlin-js-library diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml new file mode 100644 index 00000000000..dc5cd1bbcbe --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/annotations.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml new file mode 100644 index 00000000000..dea5cec6774 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/file/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml new file mode 100644 index 00000000000..a33a584b9ed --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml new file mode 100644 index 00000000000..c14ebed20ae --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/annotations.xml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml new file mode 100644 index 00000000000..6595499a4a1 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/internal/project/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml new file mode 100644 index 00000000000..87c8bc5da18 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/logging/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml new file mode 100644 index 00000000000..5859b33807e --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/plugins/annotations.xml @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml new file mode 100644 index 00000000000..67bc433ea20 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/annotations.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml new file mode 100644 index 00000000000..812dfa500fa --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/tasks/compile/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/pom.xml b/libraries/tools/kotlin-gradle-plugin/pom.xml new file mode 100644 index 00000000000..543601c16bb --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/pom.xml @@ -0,0 +1,107 @@ + + + + + 4.0.0 + + 3.0.4 + + + + org.jetbrains.kotlin + kotlin-project + 0.1-SNAPSHOT + ../../pom.xml + + + kotlin-gradle-plugin-core + jar + + + + org.jetbrains.kotlin + gradle-api + 1.4 + provided + + + + + + ${project.basedir}/src/main/kotlin + ${project.basedir}/src/test/kotlin + + + + ${project.basedir}/src/main/resources + + + + + + kotlin-maven-plugin + org.jetbrains.kotlin + ${project.version} + + + ${basedir}/kotlinAnnotation + + + + + + compile + compile + compile + + + + test-compile + test-compile + test-compile + + + + + + maven-invoker-plugin + 1.8 + + ${project.build.directory}/it + local-repo + verify + + + + create_local + pre-integration-test + + install + + + + + + maven-failsafe-plugin + 2.6 + + + + integration-test + verify + + + + + + + + + + jetbrains-utils + http://repository.jetbrains.com/utils + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java b/libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java new file mode 100644 index 00000000000..d71acde71e3 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java @@ -0,0 +1,74 @@ +package org.jetbrains.kotlin.gradle.classloaders; + + +import java.net.URL; +import java.net.URLClassLoader; +import java.util.List; + +/** + * A parent-last classloader that will try the child classloader first and then the parent. + * This takes a fair bit of doing because java really prefers parent-first. + *

+ * For those not familiar with class loading trickery, be wary + */ +public class ParentLastURLClassLoader extends ClassLoader { + private ChildURLClassLoader childClassLoader; + + public ParentLastURLClassLoader(List classpath, ClassLoader parent) { + super(Thread.currentThread().getContextClassLoader()); + + URL[] urls = classpath.toArray(new URL[classpath.size()]); + + childClassLoader = new ChildURLClassLoader(urls, new FindClassClassLoader(parent)); + } + + @Override + protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException { + try { + // first we try to find a class inside the child classloader + return childClassLoader.findClass(name); + } catch (ClassNotFoundException e) { + // didn't find it, try the parent + return super.loadClass(name, resolve); + } + } + + /** + * This class allows me to call findClass on a classloader + */ + private static class FindClassClassLoader extends ClassLoader { + public FindClassClassLoader(ClassLoader parent) { + super(parent); + } + + @Override + public Class findClass(String name) throws ClassNotFoundException { + return super.findClass(name); + } + } + + /** + * This class delegates (child then parent) for the findClass method for a URLClassLoader. + * We need this because findClass is protected in URLClassLoader + */ + private static class ChildURLClassLoader extends URLClassLoader { + private FindClassClassLoader realParent; + + public ChildURLClassLoader(URL[] urls, FindClassClassLoader realParent) { + super(urls, null); + + this.realParent = realParent; + } + + @Override + public Class findClass(String name) throws ClassNotFoundException { + try { + // first try to use the URLClassLoader findClass + return super.findClass(name); + } catch (ClassNotFoundException e) { + // if that fails, we ask our real parent classloader to load the class (we give up) + return realParent.loadClass(name); + } + } + } +} diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt new file mode 100644 index 00000000000..611f34ad2aa --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt @@ -0,0 +1,13 @@ +package org.jetbrains.kotlin.gradle.plugin + +import org.gradle.api.Plugin +import org.gradle.api.Project +import org.gradle.api.artifacts.dsl.DependencyHandler + +open class KotlinPluginWrapper: Plugin { + public override fun apply(project: Project) { + val dependencyHandler : DependencyHandler = project.getDependencies() + dependencyHandler.create("org.jetbrains.kotlin:kotlin-gradle-plugin-core:0.1-SNAPSHOT") + + } +} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin-core/src/main/resources/META-INF/gradle-plugins/kotlin.properties b/libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/kotlin.properties similarity index 85% rename from libraries/tools/kotlin-gradle-plugin-core/src/main/resources/META-INF/gradle-plugins/kotlin.properties rename to libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/kotlin.properties index 4f8cd030af6..3a22596804f 100644 --- a/libraries/tools/kotlin-gradle-plugin-core/src/main/resources/META-INF/gradle-plugins/kotlin.properties +++ b/libraries/tools/kotlin-gradle-plugin/src/main/resources/META-INF/gradle-plugins/kotlin.properties @@ -1 +1 @@ -implementation-class=org.jetbrains.kotlin.gradle.plugin.KotlinPlugin \ No newline at end of file +implementation-class=org.jetbrains.kotlin.gradle.plugin.KotlinPluginWrapper \ No newline at end of file From 308c12f45c2cd1001dfac0512f0e6c237b20a5e7 Mon Sep 17 00:00:00 2001 From: Nikita Skvortsov Date: Wed, 29 May 2013 20:15:32 +0400 Subject: [PATCH 74/92] first class loader wrapper implementation --- .../gradle/api/artifacts/dsl/annotations.xml | 5 ++++ libraries/tools/kotlin-gradle-plugin/pom.xml | 5 ++++ .../gradle/plugin/KotlinPluginWrapper.kt | 27 ++++++++++++++++--- .../plugin}/ParentLastURLClassLoader.java | 2 +- 4 files changed, 35 insertions(+), 4 deletions(-) create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/dsl/annotations.xml rename libraries/tools/kotlin-gradle-plugin/src/main/{java/org/jetbrains/kotlin/gradle/classloaders => kotlin/org/jetbrains/kotlin/gradle/plugin}/ParentLastURLClassLoader.java (98%) diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/dsl/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/dsl/annotations.xml new file mode 100644 index 00000000000..0402ed182e0 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/dsl/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/pom.xml b/libraries/tools/kotlin-gradle-plugin/pom.xml index 543601c16bb..b4eb77b2478 100644 --- a/libraries/tools/kotlin-gradle-plugin/pom.xml +++ b/libraries/tools/kotlin-gradle-plugin/pom.xml @@ -20,6 +20,11 @@ jar + + org.jetbrains.kotlin + kotlin-stdlib + ${project.version} + org.jetbrains.kotlin gradle-api diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt index 611f34ad2aa..a32bdb94c3d 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt @@ -3,11 +3,32 @@ package org.jetbrains.kotlin.gradle.plugin import org.gradle.api.Plugin import org.gradle.api.Project import org.gradle.api.artifacts.dsl.DependencyHandler +import org.gradle.api.artifacts.ConfigurationContainer +import org.gradle.api.artifacts.Dependency +import org.gradle.api.specs.Spec +import java.io.File +import java.net.URL open class KotlinPluginWrapper: Plugin { public override fun apply(project: Project) { - val dependencyHandler : DependencyHandler = project.getDependencies() - dependencyHandler.create("org.jetbrains.kotlin:kotlin-gradle-plugin-core:0.1-SNAPSHOT") + val dependencyHandler : DependencyHandler = project.getDependencies()!! + val configurationsContainer : ConfigurationContainer = project.getConfigurations()!! + val dependency = dependencyHandler.create("org.jetbrains.kotlin:kotlin-gradle-plugin-core:0.1-SNAPSHOT") + val configuration = configurationsContainer.detachedConfiguration(dependency)!! + + val kotlinPluginDependencies : List = configuration.getResolvedConfiguration()!!.getFiles(KSpec({ dep -> true }))!!.map({(f: File):URL -> f.toURI().toURL() }) + val kotlinPluginClassloader = ParentLastURLClassLoader(kotlinPluginDependencies, getClass().getClassLoader()) + val cls = Class.forName("org.jetbrains.kotlin.gradle.plugin.KotlinPlugin", true, kotlinPluginClassloader) + val pluginInstance = cls.newInstance() + val applyMethod = cls.getMethod("apply", javaClass()) + + applyMethod.invoke(pluginInstance, project); } -} \ No newline at end of file +} + +open class KSpec(val predicate: (T) -> Boolean): Spec { + public override fun isSatisfiedBy(p0: T?): Boolean { + return p0 != null && predicate(p0) + } +} diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/ParentLastURLClassLoader.java similarity index 98% rename from libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java rename to libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/ParentLastURLClassLoader.java index d71acde71e3..dec931c3baa 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/java/org/jetbrains/kotlin/gradle/classloaders/ParentLastURLClassLoader.java +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/ParentLastURLClassLoader.java @@ -1,4 +1,4 @@ -package org.jetbrains.kotlin.gradle.classloaders; +package org.jetbrains.kotlin.gradle.plugin; import java.net.URL; From 9f0acd0e98e74f88fcaa8adb1cefc3a96fc9843f Mon Sep 17 00:00:00 2001 From: Nikita Skvortsov Date: Thu, 30 May 2013 15:00:18 +0400 Subject: [PATCH 75/92] fix tests --- .../src/test/resources/testProject/alfa/build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle index dbee1e21015..14bf8d494aa 100644 --- a/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle +++ b/libraries/tools/kotlin-gradle-plugin-core/src/test/resources/testProject/alfa/build.gradle @@ -6,11 +6,11 @@ buildscript { } } dependencies { - classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT' + classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin-core:0.1-SNAPSHOT' } } -apply plugin: "kotlin" +apply plugin: org.jetbrains.kotlin.gradle.plugin.KotlinPlugin sourceSets { deploy From 5429c1333edcbee4b20c0f1b20733c066ef71feb Mon Sep 17 00:00:00 2001 From: Nikita Skvortsov Date: Thu, 30 May 2013 15:20:14 +0400 Subject: [PATCH 76/92] Tests for wrapped plugin, some polishing --- .../com/google/common/base/annotations.xml | 5 + .../com/google/common/io/annotations.xml | 5 + .../org/gradle/api/artifacts/annotations.xml | 5 + .../api/initialization/dsl/annotations.xml | 5 + libraries/tools/kotlin-gradle-plugin/pom.xml | 28 ++- .../gradle/plugin/KotlinPluginWrapper.kt | 42 ++++- .../src/main/resources/project.properties | 1 + .../kotlin/gradle/KotlinGradlePluginIT.kt | 126 ++++++++++++++ .../resources/testProject/alfa/build.gradle | 52 ++++++ .../com/google/common/base/annotations.xml | 18 ++ .../alfa/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 46735 bytes .../gradle/wrapper/gradle-wrapper.properties | 6 + .../test/resources/testProject/alfa/gradlew | 164 ++++++++++++++++++ .../resources/testProject/alfa/gradlew.bat | 90 ++++++++++ .../alfa/src/deploy/kotlin/kotlinSrc.kt | 12 ++ .../alfa/src/main/java/demo/Greeter.java | 17 ++ .../alfa/src/main/java/demo/HelloWorld.java | 18 ++ .../alfa/src/main/kotlin/helloWorld.kt | 20 +++ .../testProject/alfa/src/test/kotlin/tests.kt | 21 +++ 19 files changed, 621 insertions(+), 14 deletions(-) create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/src/main/resources/project.properties create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.properties create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt create mode 100644 libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml new file mode 100644 index 00000000000..69ed1be5713 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/base/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml new file mode 100644 index 00000000000..64ac65dcca1 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/com/google/common/io/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/annotations.xml new file mode 100644 index 00000000000..885acfdd4ab --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/artifacts/annotations.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml index a33a584b9ed..4005fe3c2c3 100644 --- a/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml +++ b/libraries/tools/kotlin-gradle-plugin/kotlinAnnotation/org/gradle/api/initialization/dsl/annotations.xml @@ -4,4 +4,9 @@ + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/pom.xml b/libraries/tools/kotlin-gradle-plugin/pom.xml index b4eb77b2478..717f6ce83d6 100644 --- a/libraries/tools/kotlin-gradle-plugin/pom.xml +++ b/libraries/tools/kotlin-gradle-plugin/pom.xml @@ -16,20 +16,31 @@ ../../pom.xml - kotlin-gradle-plugin-core + kotlin-gradle-plugin jar - org.jetbrains.kotlin - kotlin-stdlib - ${project.version} + org.jetbrains.kotlin + kotlin-stdlib + ${project.version} - org.jetbrains.kotlin - gradle-api - 1.4 - provided + org.jetbrains.kotlin + kotlin-jdk-annotations + ${project.version} + + + org.jetbrains.kotlin + gradle-api + 1.4 + provided + + + org.jetbrains.kotlin + kotlin-gradle-plugin-core + ${project.version} + provided @@ -41,6 +52,7 @@ ${project.basedir}/src/main/resources + true diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt index a32bdb94c3d..f2891244fc9 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt @@ -8,22 +8,52 @@ import org.gradle.api.artifacts.Dependency import org.gradle.api.specs.Spec import java.io.File import java.net.URL +import org.gradle.api.logging.Logging +import java.util.Properties +import java.io.FileNotFoundException open class KotlinPluginWrapper: Plugin { - public override fun apply(project: Project) { - val dependencyHandler : DependencyHandler = project.getDependencies()!! - val configurationsContainer : ConfigurationContainer = project.getConfigurations()!! - val dependency = dependencyHandler.create("org.jetbrains.kotlin:kotlin-gradle-plugin-core:0.1-SNAPSHOT") + val log = Logging.getLogger(getClass())!! + + public override fun apply(project: Project) { + val dependencyHandler : DependencyHandler = project.getBuildscript().getDependencies() + val configurationsContainer : ConfigurationContainer = project.getBuildscript().getConfigurations() + + log.debug("Loading version information") + val props = Properties() + val propFileName = "project.properties" + val inputStream = getClass().getClassLoader()!!.getResourceAsStream(propFileName) + + if (inputStream == null) { + throw FileNotFoundException("property file '" + propFileName + "' not found in the classpath") + } + + props.load(inputStream); + + val projectVersion = props.get("project.version") + log.debug("Found project version [" + projectVersion + "]") + + log.debug("Creating configuration and dependency") + val kotlinPluginCoreCoordinates = "org.jetbrains.kotlin:kotlin-gradle-plugin-core:" + projectVersion + val dependency = dependencyHandler.create(kotlinPluginCoreCoordinates) val configuration = configurationsContainer.detachedConfiguration(dependency)!! - val kotlinPluginDependencies : List = configuration.getResolvedConfiguration()!!.getFiles(KSpec({ dep -> true }))!!.map({(f: File):URL -> f.toURI().toURL() }) + log.debug("Resolving [" + kotlinPluginCoreCoordinates + "]") + val kotlinPluginDependencies : List = configuration.getResolvedConfiguration().getFiles(KSpec({ dep -> true }))!!.map({(f: File):URL -> f.toURI().toURL() }) + log.debug("Resolved files: [" + kotlinPluginDependencies.toString() + "]") + log.debug("Load plugin in parent-last URL classloader") val kotlinPluginClassloader = ParentLastURLClassLoader(kotlinPluginDependencies, getClass().getClassLoader()) + log.debug("Class loader created") val cls = Class.forName("org.jetbrains.kotlin.gradle.plugin.KotlinPlugin", true, kotlinPluginClassloader) + log.debug("Plugin class loaded") val pluginInstance = cls.newInstance() - val applyMethod = cls.getMethod("apply", javaClass()) + log.debug("Plugin class instantiated") + val applyMethod = cls.getMethod("apply", javaClass()) + log.debug("'apply' method found, invoking...") applyMethod.invoke(pluginInstance, project); + log.debug("'apply' method invoked successfully") } } diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/resources/project.properties b/libraries/tools/kotlin-gradle-plugin/src/main/resources/project.properties new file mode 100644 index 00000000000..e362614406a --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/main/resources/project.properties @@ -0,0 +1 @@ +project.version=${project.version} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt new file mode 100644 index 00000000000..68f085a6eae --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt @@ -0,0 +1,126 @@ +package org.jetbrains.kotlin.gradle + +import com.google.common.io.Files +import com.intellij.openapi.util.SystemInfo +import java.io.File +import java.util.Arrays +import java.util.Scanner +import org.junit.Before +import org.junit.After +import org.junit.Test +import kotlin.test.assertTrue +import kotlin.test.assertEquals +import kotlin.test.fail + +class BasicKotlinGradleIT { + + var workingDir: File = File(".") + + Before fun setUp() { + workingDir = Files.createTempDir() + workingDir.mkdirs() + copyRecursively(File("src/test/resources/testProject/alfa"), workingDir) + } + + + After fun tearDown() { + deleteRecursively(workingDir) + } + + Test fun testSimpleCompile() { + val projectDir = File(workingDir, "alfa") + + val pathToKotlinPluginWrapper = "-PpathToKotlinPluginWrapper=" + File("local-repo").getAbsolutePath() + val pathToKotlinPlugin = "-PpathToKotlinPlugin=" + File("../kotlin-gradle-plugin-core/local-repo").getAbsolutePath() + val cmd = if (SystemInfo.isWindows) + listOf("cmd", "/C", "gradlew.bat", "compileDeployKotlin", "build", pathToKotlinPluginWrapper, pathToKotlinPlugin, "--no-daemon", "--debug") + else + listOf("/bin/bash", "./gradlew", "compileDeployKotlin", "build", pathToKotlinPluginWrapper, pathToKotlinPlugin, "--no-daemon", "--debug") + + val builder = ProcessBuilder(cmd) + builder.directory(projectDir) + builder.redirectErrorStream(true) + val process = builder.start() + + val s = Scanner(process.getInputStream()!!) + val text = StringBuilder() + while (s.hasNextLine()) { + text append s.nextLine() + text append "\n" + } + s.close() + + val result = process.waitFor() + val buildOutput = text.toString() + + println(buildOutput) + + assertEquals(result, 0) + assertTrue(buildOutput.contains(":compileKotlin"), "Should contain ':compileKotlin'") + assertTrue(buildOutput.contains(":compileTestKotlin"), "Should contain ':compileTestKotlin'") + assertTrue(buildOutput.contains(":compileDeployKotlin"), "Should contain ':compileDeployKotlin'") + assertTrue(File(projectDir, "build/reports/tests/demo.TestSource.html").exists(), "Test report does not exist. Were tests executed?") + + // Run the build second time, assert everything is up-to-date + + val up2dateBuilder = ProcessBuilder(cmd) + up2dateBuilder.directory(projectDir) + up2dateBuilder.redirectErrorStream(true) + val up2dateProcess = up2dateBuilder.start() + + val up2dateProcessScanner = Scanner(up2dateProcess.getInputStream()!!) + val up2dateText = StringBuilder() + while (up2dateProcessScanner.hasNextLine()) { + up2dateText append up2dateProcessScanner.nextLine() + up2dateText append "\n" + } + up2dateProcessScanner.close() + + val up2dateResult = up2dateProcess.waitFor() + val up2dateBuildOutput = up2dateText.toString() + + println(up2dateBuildOutput) + + assertEquals(up2dateResult, 0) + assertTrue(up2dateBuildOutput.contains(":compileKotlin UP-TO-DATE"), "Should contain ':compileKotlin UP-TO-DATE'") + assertTrue(up2dateBuildOutput.contains(":compileTestKotlin UP-TO-DATE"), "Should contain ':compileTestKotlin UP-TO-DATE'") + assertTrue(up2dateBuildOutput.contains(":compileDeployKotlin UP-TO-DATE"), "Should contain ':compileDeployKotlin UP-TO-DATE'") + assertTrue(up2dateBuildOutput.contains(":compileJava UP-TO-DATE"), "Should contain ':compileJava UP-TO-DATE'") + } + + + fun copyRecursively(source: File, target: File) { + assertTrue(target.isDirectory()) + val targetFile = File(target, source.getName()) + if (source.isDirectory()) { + targetFile.mkdir() + val array = source.listFiles() + if (array != null) { + for (child in array) { + copyRecursively(child, targetFile) + } + } + } else { + Files.copy(source, targetFile) + } + } + + + fun deleteRecursively(f: File): Unit { + if (f.isDirectory()) { + val children = f.listFiles() + if (children != null) { + for (child in children) { + deleteRecursively(child) + } + } + val shouldBeEmpty = f.listFiles() + if (shouldBeEmpty != null) { + assertTrue(shouldBeEmpty.isEmpty()) + } else { + fail("Error listing directory content") + } + } + f.delete() + } +} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle new file mode 100644 index 00000000000..451ac3de6c0 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/build.gradle @@ -0,0 +1,52 @@ +buildscript { + repositories { + mavenCentral() + maven { + url 'file://' + pathToKotlinPlugin + } + maven { + url 'file://' + pathToKotlinPluginWrapper + } + } + dependencies { + classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT' + } +} + +apply plugin: "kotlin" + +sourceSets { + deploy +} + +repositories { + maven { + url 'file://' + pathToKotlinPlugin + } + mavenCentral() +} + +dependencies { + compile 'com.google.guava:guava:12.0' + deployCompile 'com.google.guava:guava:12.0' + testCompile 'org.testng:testng:6.8' + testRuntime 'org.jetbrains.kotlin:kotlin-stdlib:0.1-SNAPSHOT' +} + +test { + useTestNG() +} + +task show << { + buildscript.configurations.classpath.each { println it } +} + + +compileKotlin { + kotlinOptions.annotations = "externalAnnotations" +} + + +task wrapper(type: Wrapper) { + gradleVersion="1.4" +} \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml new file mode 100644 index 00000000000..be8ddab04a3 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/externalAnnotations/com/google/common/base/annotations.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..42d9b0e9c5872910311a1d035995ab8ec466e7ac GIT binary patch literal 46735 zcmagF1C%G-vM*R&wr$(CZQK5r?W(RW+qP|V*|u%lt}eX3bMCzRzB6ZLa;=@2D_88b zk%3=C>`;^e0fhzvf`kN0C*u_c`g;NY*X{2G^|#51sS43a$%`|904e^1@P>(hmhUft z>feU?e-g?G$xDfgsi@M+i9g6qPRPp8(a*uj&{0oM&NM1BF0$+%-A~euN=?a4(MZw$ zfIbf~O*t&mrfS6?D>*DO9wi2_?H%nO0skMvrTyEyK>rSB?_}|hDg8SQ%zx8ZI2oDR znEii}qWqK8-O0$o!OZFZ(Zw>r)V%O7>C)du@}Iki+PmA?*c+LWGSQpZ7&$xpM#(|< zGa?4>Sh8u;xG@C4tc2wB5jYUh^9tFB*g#21Rdi*-AnfK3qB>si9`oT(`qaK0KoN@c z_hK3g`~2oeo$xIuGiqND?klq9{`pwezyPNf#GP9BnlRPNcHG+l$n$Gh=R8MB) z=g-P0AYms)@%Cu+Z5ahg9_*EVO22khW_!p7fjAc|L_VKVf}mMqSYdHYaDve20XSDW zJl}uY>o_w{N+bI4VhkOWVm zrZjs`45Hg*h7B;)+3v!N+^1uBSfvtOqat7;H`kG2rkv{&>c7Nb3wQ6qEjtT9Ij5YaLN0GT-Tso4-6)3G85e$o7K8&jc8;MukUR=X}zac3J z@dn*5K-6M26k9@2MS%Z@^RSb(oW zp&dvFT`7NjK@mn1%}|dBtb#e|7YQ2=9tje4m1}F2^q7=rKNbEm<~@rx?((B+ZI-ia z)trI3&`-y~$Le_!?SgEX6n#|m-wKF-WaVMCv=avmK`;Q#;!t&t!8X8Lha-p7Vr(hj zA+J0e$Y*s2Ur8Oj zZ}?L4*_^^;?+PrFqU>_%k60dP9+UlCdDiQa|1ve6|RH&`-Tj zy&xg|3TVjK6d)7N$WJt;lPK4WFoF%nS#>OwgBnSQG`EbElG4>J5cnp%eVOXZUV?<0 zKD4GTMEW%|lZrzqlOU~l)YMMo#yI3r77 zj`UO_`W+?!Ni{K%+S)|>v#~B&R%3fZiK;*mCYfe%q{}%CHF}I};+a3%pTlGW#78hb zLEa@?-!Hd>3_B)WFrU|a{rsLi(Z9Y<9t?n%=VXb4Lmhdg_nFueJpyu((|+NPq{MAF zCI!)s)RP>l)bpZD)M)y}?0LeXg*54N&Hl8-Z?16l{qv^O);<$g-nnn@Q9n@aR)5A- zvg9|)*lep)GeT#d>+S_UV1ubyfu~Bt)`c2m)#*IE(@s}8q2Om>7z(@atHLx_3okP_ zVW#{{dHEp6VjX=g&?;pQO($BfA_@Dqz2i!ps_S)^X;>Fa$1kNz;H^QD1?Dcfkcl?l zKGEM-Dh)HLvJ+*``UE)B3?Ho~VKD0yosBbiDp?|CgWiC4*tdwQrbye+T(_wG^nnh& z0V;gZ1nt|*wQDY2LrCR?rQ!)Cvv%ioHr_SlF+Aw9Ge6lL2^Nr@UnRC4#qs#XPM&Qt z#5Rjm**H%~OXkI@LLUCy-52_k5Q#G-vPxz%r-D@B|rd zGh9q=vP@ZEOQ6f3sUc=QV{yLgvogu|b3!7uD-+R$@fLUkIU&?mOp9!tf+7RFHH@^C zChrW|18RH8&|TVcPM+!;G}f&lu%CqQu_B#v8Uw`4*bT;7$P*ZvhOKV`JIHEnr;b;z z$&UNcWf}H*GahmXS?y+;_L%BwB1%)NzWEysS22C%Da%JO*03?-KM0J2zsQvzH4=M) z=STg`WlCipwR$&aJp;NI<$wNUOLFlvP%iXo!yLDvO!eUs;j;8-@)Ij%nP*AB363=k zo-9^q{eX&h7KKR<|Ke949h`}$G)*{3dwj|0$$j4~)ysFqV$wcABnm?{GA(~~)pk~O ziLP21s{jkWW$Pvya{#F%5{)ma6NC9l{5(Q<7F4T?1sww)V6S{m=&^7E?}>p9^#n|H zW^J!HS&_RZy^Cg!$TP>G#90d(K2GRKCMg7moGfIgGP#Z!_l9_g-mT^@+mkA|oJ`n4 z)dlNxfxEyw3O=-n1467HN2xpL4jmT+doKvp5ObqO2!(aXG-MO=qwQG0HH1exP6|s@ zBVbc4PrLt4Y%&catj82DHoBCkC5x*swRDq2<1cfA+)146OJ$ zmB5=oyNP%Iktpx!fU?ymoO;~!p1H_*;5o@z>-m0rU;qleYYcIVD)SH#!4qfA8ZL|A zV0$Hdhyq75xo4zzN1-NHlP&j<86b}WbyTlmlA4xs(hrO|Bc!+Vz+sucG$z^ZD;C!s z?nvmQVBldWzOiOxq><7czztH(u@?oFLMw@&fd&RCF>4QmJ|Dnafc6o2&Qh#1n`{~s zrRSr`avrvc$SPstu`4Qp8%a7LUN|A2stUMf+K>`Oj$ukgjt3hVH4Q=ur!&)w&vCNB z*Htl9z(F69SM7Taa-b=OehwL_!CZ+B14xKZCWX17#&E63iVa7@UImn(IpY}>p#_b* zNL0&C(}k6lFxDNrzMUT48ta z)zJ!*0c)3l)@76J!x5U1V+|Ztt5?gGKo^v;GSHkVA3G}j8L!1F1Fy_rkqm`nVll$9 zo6e8jE5&$7_qAf;IT;lDQM09BS*{PLFcETl#`6V=$gXulAn{Al1LF3}>h>Dv!cjBJr;uVwzhl~VTWtdBoaL=o9ZV7?Q6>uaS zN{xDvxJ5LiH0Mb|Ocx@Hy~fUB+?c0)_a@f&{Gz?V!RD;G{Q_}#oWdsP)VmRo zRSx@c?ms9o*$22b@UhEP{mat$j#5xGd*odqIAn689|&IxpDPcPKc;bdpKL_IMy%5W z5=AZ#YVq!C;UlsXiXc299MoFhc{K7ruEP-$z!*2rdU|)78^8sye%-N^u{`2tonDU>{`y{Le)P-T4DyLhnPaa9_ce#h zEbD3m$l&Xo8SCK7@l~#Vl>tUTSQT7O>K}--Q6K*ZcZaSP@6yYU>4nk$R2a>bu*RQx zf)M`2>$WrWOR+a~`_ekJUYR(XPBXH3DHyJr-u-oBvc>h!2S?NS}N*5~GVP z$mCRlgbX~Ta2dM!T16&+8{y4pQ5J!(lP+SbDcZpuqB`n`QJ~8X>6GLVIj@%A>)Zq? zfm6g_1d>N+#IduVEo|qMW1KknmImA*V5n{Krdp^|`e!W~jOMIYc1NOqd}u4r(N)Oz zzri3Hd0QxK2p}LwcpxD1|Ex0=ja)2+oSn^VjsLf%OjdvM#?e6IGm*hI0P|D-g(UGaw+pOrEgPzA!hx3-R9!w{!DpKkJo0Xcufl~f~r*BdY1Au&t z5`b;;u%wu}%5Es+ZnM8^d2hF!Y^DGFKH260n%*@)jwxt`u&AdN8gLC4pK(yxFQFAa zF$<)yCeBGF%pav8kFBD#xyFMcw!6KTvs)Ikk>m_hka>j_;E6mbc&!SXk@CRLjok-> zV%R6k>6|RoA@1(|#2~{Rq1p728cY@QA&aP$J{?*qc;&|V8JKC`Fr(r5sExX_|Fxmy zLlJQ!{fgf`!)YgR7f9(h%3~kdO0wGzW=GE9DJ5vL-|i$Lm5SPxmO}>Nb=T?NWfEey7GcLgNhX0- zXYXZxes{U5YrE22P>w2n-dUV+Af8Ug%aIY^U6!osgybo^!1gD=e_3=Vz<)MPiLmh# zC8I{3`^ao5OC?2ydc@)uCZhaq(*Sm@5HK^CR7@~0v)3QEU?QSe zo?6zlNzks#C=-C`0=tkI{^4)_bsF)T+>rY2`qJ0m8QfIgWpcjNxEeYxY`|wPi^G$V zP;vLG%WSD3sUTx6qQVS@^B7C(Ji^54S)6<4HSKa>0*4)@>FB%+=vRzqS)a9=ubAEg zRfMJ;4Z%GoUOGo1AoMmB=%|Sn6`p@;&9*4C~(ivC?nlCNBr3E*Z3$}KiUHo z59wjzoVYtE*?B#?N7@4l54~Y#^;30@LQK~tWg#}Rk0e{akX#fJ09McL8lxZ8fd=n8 zn?A@_bnywgQtGD)cyHtT2zL z56}h`3u0xA2eoJ@+1p?!YGUrCNWcWNN#h^X;mMqS872xbguah&Rsc2+SE^+UaeS!| zUjy3tU8D8D4Jq_rG^g*~@c6Sv!A8)|5WCwKE%1s>+1@tDU&p6;Z8d*uKTBq@!zK84 z)x*SrW#uW<6h3;cM9BMq#s)Mx`*_RjUQvk9|@1CyxD6MT^g$MIRLNL#;NRK`$DjUbiII zsN?t@n=y^ZhIUz7;7i$Q>unfnYZF?{b6#s7VY9bu+`zJlRbF7y=$1tK8x>nV8!( zx_+;*9z*}T#2iBeq|tq@Z7r$2F{#0szM`n5 zBjmg_QqVynsy3L`B+W^w`S#Cbtas@1-E^PkiXLwq#e6%(9|&sB-@ylwME&>q)caR= z(DF9NEwde%JW^cTt~*aYzH1E2Ag@G-1M0wj1?G75rMbGfI(lN!D zhQl{vN51RfSZ{A@ByNYHXu^acHJ|xp4&RX1df5hZ0lh&9gYMj9=l6al=+&OJpR|uI zU}Ii`11`*pb^}Rj>Gx~$v?GwNd^CE^WqO+Z3#cSfB8s}zqb|Oj{1(C8jvueJv;5|y zi4jNvUmIcMJE9Zj)a<*{>sr_KeI1e-ceCWBLn}U)uwy(!+CM#XPGUFhg}D`^_43M6 zsUQ^Qle^{}j9A!;uuwl>%dWqyU+XHlz3P?eXM|n}{^^k%&kvlf{I#sBctAje|Jk}q z**Uuy+1UImu8^$>(K}Kn9@fW)$1?VUqu%bg&2Vd9@|91 zHvLR?YrdfZ`y~%2;FPF)FMgovD03@=@Wps;t zvotCInB4e%+notca!!6uce(f6E~M%c6~KKUC1amW9JvViie=PRJdQlF0lq{t1k}zh z9xbT(q<+>UNbe|~X5N3o1b-=$MR(H%_9Sc@K%DB_fBv5Qh-TfPDy@9n0{X0${mz#D zsqn2R^ewrQ*!&YY=DSLG`-SEd;*nwg!y4=}?n^F%0PJ)`_~}OYHWBDk!v9O9{kwSf zC&cMb)OUmA-?QK4O)-AdJhevgP<+Qgsg##0?akS9T4$=BFgrE(>emVSrH|Zb+ry}rXImS5i|(f$ z3Ldw!eYe;7B6}d8BM|KfS0)wLJmtCbJO%A+YfPu4vew8r=vVdCMTI)kMtm8}z@6Dt zi1i9ON;?hpCK9kEL%tLk9|RDnDpdG5*9^DoQ!M`u+h>wq?P;3W;MA` zB>&}Aj$K{R88fMYvux&Jm6$YkLsDaNW-4tG#)mdM^e`hMEjK@RE8~7i%=kd?&hrw} z`S4XL!!CA(M|~co1-ucmTZwqRT@(Tn?HmnBaOCIKc-d?Dbfs97k#s9`XsI=~N( zy7iS+P}$VAF+V-G6p5%ZqV#OaeJVuivBg$OSYNrIpC6#GGMK$?Qk}}d5d*fgD&jQHKFy*Ae=YJXjBmNG(QL9DheUHr~s)b&sjB|4_wIzMOm9wq4<@AE}ofrO_7=H`yG3)Oc>UN%exgNuH59nf2!`NJ5Ukx2pty^t54@1S(<{QZ zh}N7W_lTkq9_sq-f5q??+#z`h9Vl4}3rG;Cy_OBXL==p?w)VdOswNDhMtQmB%^!JZ531#&PKaR8E5`izF9f`tPD>7`qk>`LDehcPr z>LzOAN3D-G9c{=)oJNq~sE)Ifvk(JOyUO1#=L8oQHI*aO5*|+CzZNYO!EvJgUD$nm zNPx)`4uJFICHlf%_DE2$e2jdQ!FD<#UFcd-qo@``?!Q#Lv{))8552n<70yjrFT4B1 zUE(Cq`MtV)njk2Q$5Q>+7Z}x{-$q?G9SEh!dR2cCh0z+qWF5)o0rR0u^pKiaTD4m{>Qzwdzf55j_Qlz0T zL6bL)h=#TTTY%KGQopB$neC=tWiAXR`4G-_og0zukrdb_^bngYUY5wURODFHa$P=H z{(zW@N%q$;mr>BX2PQO$M?|(wi(&wqA5E^>t5Gz;UJKyE%@5VOw9Bgc&g26=dS@)Q za2u7*(gAi?y!IXix<}@Kg6vX3Dqsn%wgS6HM^gUI+u|zu0^o!7CnlHIX9sCa#blHzSjF2g$4`oJ(N#DT{Y!_YeD2zx zfgHlPV2L3rqb(KnfUo4baap&S4pepX5@wD5*=QR>?k{utDS-txrC_!-8RO-+O|#0$ zw0que$RH4Ic*l`KHO6Op5E+&ZXoM$bC7~KL+h~|njO$T7Kj4^bDv}n|E<{vD;mh&P z4M`)S40&#G+V5UGAm3|II>qtIvD!*iIV5%mVO?=0uGL5^s4ex*?G0M@gE2yjy=V%c z)Pbo`8{VN~qM0r~HS}$#{KWLj=pj7RZvS*YV4`}QhuQ&8g~IdTMngwog=ZWU!{e4s z1*5Qq>wD#VZ(4waN(_;r2qpO@^acM5`m4!fbgM4Ch#?I=90uCCLWTt_hwaf1LI#+- zWN$Nj?OXLS#zemKMg;FiNmKnYX0P3OZLoT8mxcLJ?2P!uX#-VWJdG_tVAS* zT$?d5qsW%D&(*lR764AhL%cxL<~pl*zwkO zKg?9RRc+HB4Qy+r_Yh5rk+5}?my55iQ!z#;7@pfQex5hBsq^7Bl5SQNM2F|VD_L?8 zU_*|N4L~i%WYWS+j+0xu4-@Rs-bQ)_uRB(RzM_f}7d#kncYL6Abe@1wo!@*1exq;8 zROs0Fu+%8j6FG8$QJdG!=$9Sc5MOW!8NCX}bn_-I1O0?JBl00CIV7ekLb^ktV>#T3 zEpdU!XpsN;@Ng)ia7GQ6GOd_bIk{3^#jAkU*MLPWpfGYQi5KrTgbN^PY?6FWW@&0| zhn|9^OD{gJ5oBZ(VH-#V05Zzj(Icx_R3QSeDng?YmJN5I=>pw>`-wO&Z&XEh?`s5| z85w0bT$5L*Ps-buf8sNb*UmzhIJ-!B(WJL8=6MCHkExbE+L?PLFV;lxh7(D`s!z^Z zDbU4ZSEUuR4PexCrAW9%#wB~2E?Ju)Qf{h{qrhQhH)POe7P^uwU3@aA9E8=n-ilde z6d%v9K}`5+log9Mr5CH`+kph|$CKOVO5{j8x--JdN&37N%EYHG(~DC zanu%WZOVJUx}EQRHl@bS^XC*X3W&OQV0uNN|8l43N}dKzF$n4movX~#y7da$2KV(( zgYBR7=HY`@O};N&eS;^IIcj{A_rgt4y+dvC!ll%kM(>K;2Ju!GS@!O$jaqgJ+749% z!~PE1zLDlp5XeI?)RiXyc82rmN-t%4Fq(X2dO#ZObzUA|^hGlO+qvdC7i6?Y!%WRB z+_+tv-FcQS-C5Dn*3rKB86s@kT#VB(PCAP-6Tgg2+acVNJbP@O&*6>*zY8f)~;40?6&_@MYm&UuaWC@t1z zBka}@vd{Q~gQ8ZKkmT#UI*_Dzw5g^~Ykm0$;oZWrBX!(8tCY>NcW2Mc6#g8;@&@+` zH@#4gM0lG|ro#fDps|MgWGG^vO1!t zp=dkWE_h{YXXhEadM0s8z<_T4Qq2)h11i->$Nl1Qzk?{fn5d1f4i3jy|ziIhG5d~n@6&A!M z`EH*5rmAN&8jX4)Y?A6$W;OEqv{w2V<}7+=Lcho?57E9zFq3yXI=yzq+E1AAvhw@7 zQ_e+LSXJ+(sGkfT^|IW-vwnEs7jZ8>n(fk{FM8t6H?U>F^_=1Jk=?7vYfqQv6$3fT zL}tQXz2a`)Y}7YAC0kg!Hbz!2C*%B}N1c%GS=>?H85;3Ppd_pwqpAmoCrSbW6B88q zp&5ZZ>;GsUGN8@09ae-<%r2x0Qf9vCL^!fU>ogF`cX2A#zF*Nvc2PrTH)izFCF*=8 z`i%swfYtqs3m4loIj_U38~xa#mrtS`4Kat6%(7b+`s6*M)TKF39cWT#77_zeXkZQh zZg$+wHUHzWJ{~wj3p=-X6c!7khL7Ts!pXvpCr(IG5e=;j`iTNE-8%lUTJn|0aFV|0 z0@T3-mB-$w+l5M(9ZqUM&Y^qIH&f2%>1!<`R|dkhUO^^m}&*x)@R?rF;TzlNvyifrya1S znS3YT40WI+qFzTj|Fm$VG;=kZyp_`zJv5xthewEAWpR!Lj8lYsV>0Et*iG(Km3q+7 z;L&&FE*t|iXNCEdeA;h;e>%kyo7jW>f75iy|L>W1VS9TQXP3X}cR3?~or;T*lgt0) z=(Kb;)Dijm8_ZP6{I!r11+##L%29n?B)u zuVf4|F$OfcOKv_fe9wCCJ0>Tyxh#&ik&(eoS&h{CGooB=Bwu@DN!=g9 z5Hfu{E=NL{`TIwZ`R_!ICg`v<;u7M}cQa>Ur*cqtp(K{U!c@#Npe!S-!F8rBTGE;; z?9ND`2B(rLYAaKQU&Qh)Z!Ecf#J2*>jIm_oE@+<@m0zCI&^jzK+@?#W5-PBubee6< zqhW53UzG*zJy^OcuPd4K*qG~sYyslto5_~uHsT9wt$`BF%&7UzG4()ea9kGVP!mJr z1HjmNR{>T??@55w%if&%C0%;E3V?Wjo_D{Yn~g1*e#w4lW6(MhlqFTU42=V1}XJ=0yiq+mcs| z6GRJmHRCF5&W<|H6@}XB3|y;Ka~G3@!Hf)fLWRLuj1TG&Q=Fv%PtX`g_^3e+dVM^t zbi4ChFlWYm^qNwN)9IW2U*i zW5k5;{{-cf=2)tkDfFq}LR#{p?Ch);OG|R9-eU1H5Yd$UqVKG+bwo9wd_^{(@(8I7 zPsQ56(?`jqBXj0M3gFA zcF5A?;7(SAMdqkoXk)G8c}=vqlX?+L?Gbas)kFaL_&rl9W`78)iA7v%TT`u=pE(eJ zf59)HuT}n5VAeUzET3|v)<(b7PB(BlXf$oUHXf>Wujt$FnLO#2r#+eHB_Yk1hkBN! z(utI`1T=_UX`T8*(5% zL!TJw%q*E>cl) zQEvhKzes--S;Re8<1pYh;mWt598(8h6!>z0hfhJ)r;*`bfCdj_Ip?Dq-K&9uz(2w@ z5D<^@^A0jrx6UAmhIdFhBiPONATzvK4byc>sgsD!*Id)hM<s`KMt%R%(>10{`NCoKw=KdMLaQgYwM)`4nV?fcG z0IN%f#4o;r)c(y`EeH_|77vA#Z8ZKSryYw-B=4Hg9|C!e8GpA=ykvrl;!+cAvrSeV z`USMr>)nLR)wz&F%N@Q8)^jk}_UGRsgyuRMcS3*9D>S160a5FTYsgxtLg*H-yLCn@2S!-1+QjUQKo4I?d&vE0qs?DD17$;cMzn){gxjdY z#<*2vN10|Gk+Am3d$#?)EwC?;V;dqKp*}lQJU0nz`H0(eJ1?WR+lbo~J1-NrzYzH; zcM!%LIK#X}Uh7Uj!fv-Q#35qB)L57^lh;0pcnQ%3FbA_{c_}H}$1V$ncu|KvIWhYO z?tMvvVuNq*5b@#mP>6h(gA~S|=Lqp(Od8{SwYziU_fCa*V`d_fX29;=7`<-6lpy?l^Uu1@jR(=oAduc-v6%y8D3 z8=9GQ)}%PC)3vr5;P^@n%dHKz+2`>@f_>LDHHz9dB^O4yQ|B3ZOzHG5m#Sd#uqQXx zI`t5bTHDDomsqH5`-ybpSXnxvq`)rTWvv@b=I50GT_&}~@uTOM&OLhYa@+GZ1Cw#( zeyM=Dye+T!Yj)b0l4gUx-zmy8)RnyPIXS*w%nC-TNTtbbSQfR*Bs(&z4!1gxtnY3i*n zDvNZB+VWGeg0;lO8x^0ey9l9pda+C@xqF)+?wBu9xNgKk^zF(^p;KGhdXiJ&EaHuZ zZ>iB~;OV?1lRilkNS4y%xMq~d{b{o4A;$-#?alAoDXIN4;p#jbOLbBy?4*SUe+G5}Wygbtfh#&AS8M9(`1* z*ADz}(*Km0z2LOro<*RCpvV_=h;1mUvtAJ!^qqej=r3N($biwAJzg_k(``iBs)-@* z`p58j}o8T;Xsa^J}QHwKH81oFP^5Ps&+Z?K4u2%0;yiz3> z`-m-wt8Wyi}Qns1qXCgXmzANC%-M&o{{ z!=KZ*$O%Pub;;CZ3M-3k$HE7CA2*hVMy+?S3Uyp$*9=KLelS^h?5FI0ablRl%2`*yQdF>Fc%c5ku7epjU1 zd)WM0qGP6asNg)Ibx&GskdcOdsZeup4AwvIVcFcT-IT?ld9trC$fD_CPi;!#M-8gz zzI007H!HO+FRS3!2yfL5N_wkry0%Me;)$x7z?^==xDJ;{d7v|<=(ZFup>?+3qf(b) z3O`JuM{AS3=Hf45{=IPnV_&vE(ONH<d(PS%wo)JL?D z6?+N_S?w_Gm-Rn_DEIY0mUCd9&*{_>o#cyy!GV9Y@nL**BTmU0*l+)1L3c} znjz>%6aPw~nhL}duhAC$>8IrGr!!rIKg)8u6h0SAVWVafo}$+}ClfR)Z};TK?ntiu z5Hn;W53Sg}z)nACPV%B=@~wE$%X7pG;n@xvHD|daca0>j@HTgr=?<6^I5z%8bMvz}bvWE&JMD42z+PPJoZA#PVN}K;tzpkQPVwC1z)(3$J_Os%>8i zncN6sE$UssC$a#hZ9e98#^^K_4iz0Mhu76k&+^VM^6oDM)7x0r+g9#3vKIDJM69-u zoH@BiUfa|;wUCnqZ}HxMJ8jP+2N&P#K`PuC37{#>D41D)7_8k$2khlUbCABB(Ji^t zA+jJ(mYSjB!<(X@2?vzlyLK)-oY@MXcKyt!t72M%z=>&2h#ez+@{Z;SlxowmidDy1 z_RKNJov3ezHgJxBGZM`U`~heRp=*&(SmRBjR$vxOo=xp2t-(1rux9(<2wT|^euK?r z5A{XH=vtu+by;V$U5)|g#=Jk$76^zgB=N7X>#@dTxZG)3cUoC|kO9o9A?F z_Zb6aD2-Xfbk}##+p31;oP?7x5k&XHv23soD)Mc?vk~$tp-n>T>UJDUy=8f=(Ml~1 z&}a`~&K%G$pkU?DXj(#fJ|Ag^G8!>gd1-7BG*(y!HF#XHcHgv1g2dkWXn~=+d;NL` z@}L>Srq9sCSo`nMUuIi>X-dATPvu)=0U2!XNPE}r+FuX_K^)>(Osmh8akD1W#XH*4 zf*O(af#z46nO;zG_lL3HZ;18|^_GD=RR~|zINd8~i-SyU$xuC*Ume88GSo(AP1FW4 zA1TK~2fKq(a%K;Y1EVCi?a_`J4i?59!p&9|J`A zvgxbfB5*G4Z$X>UZ(lptm*>@wEtJi2=l^_K_@__q?QZBt_7{f2|AnE{{~3l#{9pAu z{|!d}%P;@$l(hzg2hI_e-?!%7*h%BTsJxAZRuE~*(I9bE+?;h0*4(K&Ck2mZCromhldNAV%NR+VY0M|w1Z!BEvhrosY$gvwT& zMri(mU3|0+$J&U-)|uGYaTbDyg9B)OqR`x=%$JEN2-3nopRY-#j{pJuzdmXCJz&je zIX2Vun@fPdb|1z=vJd0)HG%iTOrV=Mda$~7{L7kc@#_M*JKq?y^z*gkvgc@|#q1mJ zS4z&d@7!HqphOLJ^fT-;J{G|R9$&+EuVSsB;Vt)PE56kES@~$1E!n(E2iUU4JRTMn zALBfam&5(2;7yUBUQ7D)y4QNn?B6n%4~)4Nc!k!YC2!=jpe~I(>P04^-3#^u-a2E( zc=izI^1={TMS%=fQh1gU3JMn*qLU%9T)ym4Xd5in>hjT~;*mu0!=Pdd<`A^D@pODA z3lT43xy^1=?_W##1Ch;6MHkDcZ){#RFlA!XpY3FdH_D`wqurwOyLP_A%xwUQs486~ zMcRcXZ{#A|(VX#hajPOxLD1{FtZYf~cv7}+@vhQiB=#ZJyj@@3^{S~X2+DOw8BX7 zLHkKe{K)v~$9tHlm_81Tr>n-i#}ITc z)sTUZ@n-4LTH5!*EF}?3r1U)Ki>;w1BZ*;&Kg06Hwx6bBW<_@tSUXO-5!J-yQPl-$ zPy^%KsB+HC=;D@Jj;XzJxWe^ORq2h!;;b^*A_`Dd)J7LF7EZrACJWc+bcwMD*o?)A zO;Sg3pN}Xn^h%=_#Qsd7F5Tbce{X`SkKk(AJ=W?c`ROGThDhla62+)s%kKw;P-Q9J z>cQ;{ys#C;E#HECD2l+3uzf%ZsNbT%2@K7EE_;{?<SzPT@a@as$pC%?mn2 z016|~$bB$ zQEAg*%ABv+gyg{Cvs4=**~PK(di*^Zi+SMctU80;_dK=sOkXnDxe6jt%VPYS{Co(S zs$K|%rnq%EERlMHmP2Dani{wuo*$Pz5MHWI5;;poM0m9LAZh+k?UQYeR2^X4Y>D2Q z#2Yb&E6cNnJ82%Jxv$wD27z+se0!rT8cDA02p5?p@ip(fWgc^au5CF@F6ODHyvEif z%4F#j)m{UjSi_;Nb(E_@o5F@S*3D~cAk?E`8qcets-GR?uFnx8nLlD)83YH+GZ%IM z`onUVFYhbXk-xgJ;Ddw3TlsgA?%9-jc`E{4~7jZ};ENu>i$CvPNm1Ao>O z`}(-h84g6?rSFagWOYG3n0(*NF4f^0IKMaZm5#^iLWyWQc7dj9W-- zTB(@br@SyMt~Ga+K6{*&N4UX#<~%scQNy>$M&1*R;Ja$KcA0Z-7`WKv%1PsYVOvJN z-%OpiI*I(E@>|Nzd=b8l#{W1C*PKrhBm6iO>X=1Z5;ZJ}bFs%v zUqsEj*4}RC<&9h))3Qwb)ed}a@fW+oC4yCD2^oS%H(F+7^;Phy&zP(Ur#C$1XBQ%# zBZ-qN>4(~iVhTaf_hQn!)m^*Z?NSB_zQioseWKeOn7(^^gzI3S0O3Mk_c76 zJ9WUXsEiajOUH>P6F`gcITzI!@9;;O_giCSiP8LF6Uo+j(46>g|N9*9tePi4b&unkLkmu=U04Hbv(45kb??0SA5d z%a2IIAW^iQRP2jUiV;w zG+Bdn$$v0vWk{;4DBAFg+25!}Z)yp|(ipUQgp!VRcoo|nv4-3hh2(t9BjTV&&x1PW zxHZnePpk@oC8FqpB8;t$B6b8Wh(Itq(4rP*-wAvcEihXY`3hDyUE*bSnJWTcs@^qC zr)y*S@_wv)$=$7Yts}y-{hPL}g(<2aCcYzE-|Kg-BaRu3w?-}uK!I`1I;Vu z-TapP*nvWXp?`NnO6I2IN>(@+UuP%?yd(q1rm$qW$(TIt{NqrYkDt)dHJ(=_ekQ zqA-2{(?VblSOO6g@~cDY%)E@+RVAyMR=+wsk>P;ltFly9!J7;)e`Dc)vycT1gGl5v zfvQpu7hK(v-zCgAPSfx99(hxHt$>L2?1|oZQ;Om6wFV;r3a;BM_KKoky7iH zGvk;rjS<+GHsRu6xfVWQFZfoc+3$Okz6a08dOOXa_h|R;+T|%orgFhou&&H`6u?<| zfO}63&8@1*ZG-CC2`T|!gUd^$Iq!&%p{lFuC?!GDomU8Euy{x2qt(z;u-6cidZ)(a zBR8^g7ftw)Tb{#s_4jKgxBgIzOJ~Rm+u+ghhVpepk?!0r9^B5-Eg#&@%56vpf#qv{ z1cz&9FhTiieMD}Vht3aFOsEOuY0+&Ly*=tvIXx#nCCOQy)7&ZeZsYN|#;RM7;BsRwgjdu^Dzq?5y{;6T#luqo(~qas2VN{ge;0qA$* zm-9`Tvs^XAw7SN}xr9kA;|kR@lxgQ<-R&1Ei^-3wv%|w~VOWnyE^{OAc{lWZn3(jb z$XBq?d`Jqv#csnRTb7Ak{K?g2AG`d+u&J}V0h=hP8SUQ%d4>{Xx-uUBi?Mf%u54?! zg{vwRR_v8z#kP%#ZQHh;RK>RKq+;8)ZQFLf?DL*;?>_rI-)Z;9Xlu2$=8rko9FO|w zPk*kGj|7Nj(||k)BR_Z~=0=TxThq=rLbCg`6dE+fiWV%^vx-^LTBAWZ2F>K_vXjmG z%(|}KRim6cWNc580kN|d)J@%N)wtwQbZz$ePp-VbFr^|H2ul=_Q0ZS2a`b5i4~b7> z7{xj>a}-;4$qqFl4_t;Q5;zOAl0enqXobU^SHLPt5yTA)D&tHBqdOcmd35KBg(0L0 z;#j!oYEbiiB2>KF)TSUO-NFy$bd*$7RsTqqq(YUH4HqZGos}!;E;^Y93#X0Zhv%Qh z#3Inom0s3Cp+`GGWA*y|eq+_qk$~Mv(vd>rs$i9iQ^ea*x{?Rs>6t*mYL^x~d;Lh1 za%(Bx)&%M3q)~hw?yR`N1nKB=2P+>^M2sc(GTwZ61Ua#%D%|1D!dDN4q5DIXt(I_m z-H!EMv@H$x9@c@*8a_b>cTL;F4Mkp#+4!3ujJs1?ah1{Lham`qik@m%QKRLibz`pH zQYREQ<0Zm5`lHHzKe+y`2Pj5vbxB^Up`&_{oWcsQ%EQE=oH_bdd`VWl}5qsz7|(o7c|>a+8W@&5mTu997WNBNccp z&}(rhr-dUE$Ivzwr;hzv`&ny}^piv@`IC9gEg;H`5!uAatmaGt^WYP6*fRN6Iy{)PG zRnEl9fQ8x|cJAhHNowZX%<*Tedu(D;wN?eajk0gEqaX{lq@bEiB021YCf60RBnRiLh?be5F_sdo>}|YueXz$)bfGVBI&j=QcLW|?jGHy97iCKq`~vl| z`ZtO|!%I}6cm#7$E0an@3EuAnMow^a}Q8al#hk0Mxbe7!2 zee8byy!+DP9b2p`9NDvWjy`SCK$us8M(zBf)aj04vk(Junw~ z(uM6zuOUs+7qcAjRDK(+A@^{TK-bE!Gj7q-nZR7Nop~ETX7l|L=-bI+S*d=5Tvz#5 z=SPHeqW(6QK-5f<7+y-eaQQUz=smP1x#ACE;aC=fO=67L=s?wq2>~a&w2;$nR@9)= z1bNzNl0q3mViKn5jbhKB-wp(I7;;CQI^@7GF!>`H#yGJOS*G~;0J)?2Nm}rEzGG&v zii*OP1!tF-h#844vRb+{OK1~ttxZdpXhZjY>8V>Yop=y%vMV3&gA|uuv^S20euea{ z;^=2ckBpKpWnuCMU-q1l`q|3)Y9ArGVva0-&PVcZ&Un?BbV5`>sWDv#K-9kfgPEh3 zj`~CDGZ6o^{u0*tmt+ssf9mj1{fCl{&1W|#wax$0nvowLlO`JzRTL4G92p&<92%Y2 zk-Hz8kiQfgm8Y$ip{1>&|B5dTYPm~?AUrhQg5?Ur-72g5JJI2lX+E}i#$L?~*t_yxCxRO%hO$MjZ zz76qN&KMOIyZ4^u1WQavaZ=br%iMR4>kE zB>nh#dflxQDNZv32MfalLru+!c1Op@_sWQBXh4Z9vO$=RVn6A8WBqs?Ogrb+$P8(Q zU=^UxK0susR-$keUd%WGJ#S4((>SRpDWQGCbl#z*cpk$bxww|G&NgqEc*9+2=*gfS za2=mui43h?#&YX3Py2(Tu3o<+rDny9S+Qh1_N=~Ce$C0DWsugBZDDC>!vm8=RH0ZY z)NmMePU8nZyC$2G^c)|5U064E(`9L&MCO&|naTndRE)w3?tXCA7qj7Dvj)dhUE3%b zoM@0O{&n7>eD0NO{nP}!#^H)~ljmUl`cfxkb?Dr{0^L7S0|nbR{0Boad(f#zymmga zZIOC5XYDz!w$Kzk256l1AT8(Mu)B!1hqw-b6UvTAxMJir_a}i`b>S0?PFOuMec@iNIscffq1#hTPvFXc;kQf9~t&pEB zRBUa(CirRrm(4*85pT@Ykfc18w6hSsfZaa05Vr>Itnb0oO0vt%RRp zJ_Dp_Ao;5@a6#q_B682@f~!50Z=g1prZMHpIR}oJt=Li2(H=o;(?YZ~LHV3|;DoMe zr3UfTIhwuW;34TKSgWUYk-id3XooKy)rN4c@Yb@MRIV=CqGE)xS_Jp;oYn#vEcnil zYiGS!ifq#9B9N#dm@E3xx9nYY!YahI=ucM}e%~1y?1!|ZW3;3-J_dGq2Au?B9?J+q zTa*tE%v5*%MnAs(cO#?MHjFIzw3frq^$*U?Uq<#fYmw2lvp2N+FA*{SFy6mJ!~{P~ z>ePNX?KKCP^H0bie;4dR>UAojGW{lcXG6{TD-cm$quGZ0h6l%J{p8K%+aP=(1iyga zp@mibre#@D<)Gw>nC7|p7>Oxx#gX75hIZqS51@Q<+_^RvhiBxMUlm_eN{JH6H@AJ@ z8jtWZ$XTssEZ!jkh<6mtC#o5|lfRWikoO@XddvpmVSEU>@h!{)4Bb8RIs6sojw;#X zA3hYyr=>Xi(?dLfefh%q?;hgcpH+CYWhVw%xLV2I4bcps5#T2U4v6}Li5ZeMON>kB%^u=v)32`MJ@A4fdeOYT@Wfql zS|tB?n%!1~s2 zB-DGWMrrT66SeII=F(FJxYBvu$^Fh1D9@XlM=CYyfVl>&t-43~nj@5or$(`%LUYJ& zn=C6JOIf6;1+;DM&?QZ}U!E)jRQjxBxO1m%O6E#W#woNK4h>q(F6_)xISOWbdXgT- z^BhPrQp?Su2!5_RhgBBWb*bLo<;l@YzBiS}?z?nxgv6AzAKrNou-4FY%5KPJ>fIHi_-nVGxo94MI*0p_@vJgibOj>VO9!hwvb*kudS?^&P z5G>=;5M8J_p4r?2Kl0w=v-gX_(Re#Xf zLBD+YOCRwcvGm`!{=fFT{3ps}W&HW8jqa!9*MDi}r7Q4$21?|2BMw7d%WQlFK?+h7 zs4~iYh!{kCQ$0S5-tYW54cQXIF@}k!R>9t&QtOu0t|ncr z*I)MAtUFw1Xby0=zmjf8|Nc6PPCJ{UuO!^{WgtyW0(e6%Szn~jD;%6{J!e;{6ONaV zx@5G8;;c*$tw<%zZH{#+a^b&NMMkgTXx_d4natkHMuEF0Ohm17LQ^g*L2-`!QC{`s z-wN)$Lr27nAZQDr^3X=K%0G5RN{xvLnuIwbgAdR_+DgMYAOd3?X^D64G6dzyYuT<@A-uW5@S+{2 zmLzx8Y*_)v^4K4KNWv(IO}qpLN(RpJp(=cjrme^6tFlh^nDiaGb&za!DPr0XM*d@Z z>wvwFw1OXfYI<~G4)UQ}S{JEV!BzS4aQEFT0yDHzC(!#x2pEir%7;UCCSoefFw^6N z;xj&vr-0grT@&=2I%&`)<-9@Z+AobE2t`f!t~osy@VTs&89ahv9lysndT>j?TVrIP~{}@qBace{Bgw32oB=Omk6`4WBvfR{q`z6w03%X z4o0n9qZCCR=rIx<4(Asq^C!;jrZA`zk($>Wcla?$jb7-ZIy_**(<`mZUdyIIz#(+? zb(cWefngbC#Wj^x#RzbRPb-R{nM#CT7F7H3cBbU{)d{PQ(V)=!_$KkFt^8G*55f5Q-ek4{}9$G`O*w8jqC$S0zF+>L$W zXwB5Q0GH<8OK>1Y(b>@uspNS!Nzv4EOb#oqsvHoYm|SCZ8`iqM=5*i^vMRlpVYS>) z>8rZ*ZGT*MU!gCcuF z%#n*PixC||wP9u1eNj`v`iK!D5O{qgJFQ8rDy@00Pn<1H;rG%ev02nZMPzvA@P-rVb>EqHv12}`sMuMr?o$!9rJI0#h@qe&T)@@$!e~mpCJ0{jQdlq;w7=Rv6%d zcT>ez{R<|Eo-@QGYx2l;F`Bpr4_E$*@uV^SZ`s%syz|Y!WuF;#a+^I>FeRr%^Cm*f z|KN==yWn62EUJCOyr3(CoLMl7W^qnb&SE56QmP-d;z$N8NGj`S%U89eC}WcAQccjv zjY{bNSF~!@yx#J}b3oZsl&JJI<(%P6#(nnVCC47zBJqYD#EeT6T=6JmbQvKmNP|YS zlpB~9wg=^=GZ?^qI4Pkj@U_9|@U}|7e1E_DfREa%YH;UOx2^U~JZp8h{`^R9J>4GF z{)%Zgl@(vL^Q;L5e&3Iu=HwLX({f1$>a54ZUjbRFZKKs-X_c43tS;)0{<k(>1wbBJk{I}1rJbYM7&aIJRxqe_V_ zdZ;2!m>_fT*<&j^f}(S5KI_#iPiBt4@wuJ# zmhF-@N)WBpeD_|;)9i$6Q7XqSqsfK>P>;1ByIN5J^l2F|96;U54DZ!>1^vZ%&^eC4 zO_}gH!Qhd%L_1%mX*WGhu`k;hDJDnjBR8RLXXmefZOJNKw(_!on>=umAAL6oub0Th zCpVG-r1P5?fGN%tMbu02htx|FV3om1>PyyUNbQAU4```b2MFkI$w&1e6(LFM*SLT+ z1Q}N;at5N>VmKp>ODWKKuloA_0JOBzuEc zKgtUTE``zTYK|U0RF49q*$M#6YFQ3#_pdtUJ*I3PC#aTIbkfo-+u(hKj9GlW!Y8B? zTXaHCl~6rbqG!U?=IotE5WK!cskeOQW;H=&%IY*6zQEh*c2BeJ;9w>r8R;uhF3LdCiN1Od{l{D3gwY8nJ7jUApQXJ?o{dEaqcMV^m1?bk znr9LM;Aoqbqyp%McTi9%^Bqp+qoS z8iMtXqb;a6n(`H#EzAe%glvD<<78Sdlu8TJ>hrX6qZ*C;=~ zt{}=K#ZQiCb0s0s(eQTq_z6-5yHM(>^2J=ly5Q@@_bdn$;m-?l8Xl^#Q1-0o1RY$v zL-S2>PXeBY1M)8zk6)T^lvY?o8D#29Qkn|cz%~NKy4z$-PG^vD5QmauUd$ zdj1@*fLVu1s6VnvQ4xfD0VXQR^g?y_0;muSn(CV9(_zwhD7Krz@U>)=wWyGLj0^^I z_K%51=BO4f!}Qy@?p40?^+RaUhY1^o?+5{)KDf{lsZkXobc^JViu!U_e8iMz+HfIY z%)F^Lrom9s8+MtTAyv==)OS*e)5)?zXLMwi?f0ba$6*ThIl}w$r=SkXHDhUXGuo}& z7&$#}9g*R8sDxX-E|b+xYv9p21}u^w>Y?X3qbXNkpyR8;enIcIyoAg{^dH9wrsO@j zz9ri}fM2g-Amq+H`L;bSk!mK%DjajsVl3<@FG4bA(iVht1qWT7IasajHJks7Eo?ZS zqwyru0PrBPodIWyqraP)9~vG@nAdRV0M|X!M*QOnpNYxycLu;s3NO>4b=&2O1(>+5 z&tNi*WDK&nZ=|e9tC%_EDBvWmM&gSJB5@F{@IC7_w-?mRJG-xXt&|M5yg~@H;XOi` z2#IL!WTZu$mkg8=?epIVAAiBrTfZ_~H$Lse>N6GQ`G2t!MJx0FB@u2@6qiPlMSef8 zok=+QlK-<04L_%rKRYfk1UEz=7m^n#4zxv_10Y<;V8E{U?(@;-PsoXgW+nNlb%x1e zb?b~ikuD|XA5%}gnr45|bntTCw856{_4xK#>T+691nFwqFhVxRpug>Hq=?C#_Td6uP2>jyp)LCh6vAD8RrD2dLWi5|p(9o*A)##$PACdag zd$t{7dZM^00`$nh>(%tdYq}2W*klV`5waSymt4upb=iU+q4kJcIv|_BLL#izSuSW8 z%qomzU?wrCcpPQtcUdBnvt7eCtdm=wT^sP2neGcs`_?euWFF!P5A7~3iD|WIN zlz*86X4W#5uHW24Kx#=nfm-Mk34Ef9=(V*Euip`OHl=m!JQC}WQZg^t@&ioETQ zXD<0#9!E-JzE)X5nrFXc<*9JL5Ntw4(nC4Aur5+mh1Fg?Uv3z^ z)n`ExJgfVBbYTVRmi;m{cshr>ecNl66MHAC#gpwFQ;p17>`p`hhy07YI3w^eIe4{V zA*fFo%>vxtL~A37>oc8*mi>nw%um0>FxLl0C9LtQU~c%f@`EGF8OTSO_Ve%=WoA`Q z92#j)4zzD0r<*E%gWiPRtmyS0)efd0@+Jy_l)a@K2URv63Z*1_ZFZ6t5Ljf%R4&T^ zYlS|bL&vrMDmQDZ||46FEXJg!c2el4!917aIxFPj&U(t zU9nyx;vrU#NtQjdskU*|@MC&3?S75nl&Dt{zU?Rc9(bv$v=g)5W*v~l{#Q&@9{HtvIS1}*1q^^vljJ^g!hZOTwPoYyBMS+%3&!Q|5 zYK}Z4N24@bCSNIVmoW@Te`K(opNO*^YF$R-S)>Vy=2%wF{WMwkO!CaXe9i#qCS)-6 z6d7mRcpB$+_uk;9c-pzp_6E76ZV%PxF;X1uoBF*(ecI!JX0@fy){_1c`v;_lkKj{X z-uBG*^Ud-Q!=|_75O>?#S!qvdu!MZWIT(Q;o6@izOLx~wczLJ*^zvW^{Q|?)7Nj(Ce50~Wx>@o zm$lve9GHO@m=MMT9a%~7-G0U)Cd3`u+O zT0uS*j26^$3XL%n*Ee1EWk!OR`KD^vs~DU8hSo|3E)1I<8}rh!x?sgNx1pNfKDnHC zsD_gsfiB)GL%W`9>urwCH3Tu{Zu!kRPYe@zzQNXgKP`XWUS3mpu?ShpmL((Cu>A6D zGD;G}OI_y&l`NF=Ycfcg*YBttza_P7s;FWT*T~g_(iZa=S@O}iZ`9yR%V;oj;*|hQ zBYA%1A|aH9$#ogjvSK-F*3vZGVZ`d>Aa9@5(G%&x4NxdGCGC-uow`IRH?8C)A5v-} zcWDd|j%x{L*H-`l!Egk;Q=d&(eR46dcY*^D*xW-Z_O3C%QCXh=u`qXA+6uSOr*C_& z@9m9F)h~f?@7g4(A`=yy$e;sd&)cYm&iYgIDyxIt>FUZ$MVl0|@C>aFqu0!UjfZjh zE>cecoY7#CRwg;8K%I&9L7sTmMbLzy7q5W@ zQZOuK+v7n+qTgY!trw2pv6t{ZX4aXQKLH|WEyUjR0x1C;sjRI zm#6LG>-p&ysp#XEG;^$z=oy%7V^)q(`;0IwWqRYlyt~*`o7J)eXxNs-d0r{CrGwaY-OzetW$}_4yIfPyHP6!-tg7>_u6&h01(Bt17OT?6TzwPWbzn#QrV=##G z0HLB7fH~FJPIB{gZ~|$`Ajpt}wbFTzW3CfEAIgj45WRD4dYhn~OySrpu+X_+p1XOK z{;tH-pK}{C`ehD?--aNE*@M!&P3~O4+7gkP)Ni@E$x{j7>`aqRxyr+P|Bv|zk&V}%9Y@?)m$ z$)p|G*#7y|_=5b972b#-y;>DeDD9p%D`5b9`&x6b`{_>vB^OM{KpQvcTzf(>B=cB&=AM7n&PV+CSDOZhZjgzEgZOXQD7?}{66|y!V zzR6EyAE;=~M`qE0vq2*zBN8I%H)&7u+pbThsbXslWRQwT&5h0ZD%XR?dDG3o#f9;g zz{hO@Ur8KlX0A9+3kCz}{FwbPJoztoqrZ`NrI%A)2G1F>E^~6esQh zbBgQ1vw(el!E9z0J(F?A!|YMohXU!cW){`wvLYOcX^dNcdT6w{eS(j1-=Gp&69AQ> zN~W4EH}ZZ6Nky^2KL2tMc_zNDUmy^S_Ed?)9B2NFI88S^`tH%qG1J&9lfenaZ;CiXHHGA)+d+xNfz)(7MTJWk zN>}soV_X^vYqWsy(T#s$>fepY6v@c(1v{11H9 z;BUD2f5PC(=FXoS)3w}%!JV%DZiwCQx$wS*csAIzMD_Z55VOB5)HKNbBp1Zv24VoSz)!*W(mv_}`t}(Bvw67_|?%Nn*h|ICl_UiUC+|Qd1 zGTJWK4u&(|KQ=xdS87(^H$us7o`0yf(dmk;ZCW5bAb+7cR zZb;4^$t>vJl5H;SQ96Ql5;2}HOPpGNq4|%AlWQqWnkH(FP%GZkNVP;LlFKmIj-b-6E80;X2jvPY-Vh#QAM)Jaxl=c0qT#EDWDxjM9i~T zq*ju5%Wr%pBjtJoN<((SC>Fzv=vYpY1FZ6lf#6c)L0FYH1rP})1;sy%B@X;lMq;=laY2*os>QMDJB(L`xp?Oh zoY#xLFV;U6mYFS-mv98(fesmAppGz+--9iFiWPC%QuXjQR28&s_ivYLj$E9N{+uK_ zj8wKL+hEoVl;Pms@!w-Z~n zfN$-D2CCLr>a<$k2<0b8V=|PXf`kbbj;WYd86^xe8XSCWQDHnFZ0fG9F+n39y)mlN z>K)S22VLs)SCl!2;$}cU_=8e9n^oGT(F|4KZX<{!IxCl76@F?WTmDTaJ$gbsk|bPj zPQ%}P-{`irVO{72V=EGDah-jk15Cqmxt!g8A5T2au)5ExfmL$=yOqxlG)TZ}kM2NvH#?bBkiy#yyv*hXO>^9pstUr{V2 zoHKF$Q=D8^@Zkh~Ko|IO$pyUFjtS{FWc__{{7CWM&%GkkIeO|NTPkRC*`0QzzkaGK z_F!FcTPR+iI-Y7A%-Er>5tgkdI19aGpzgLlWzftwhEqK?|L_Rl7@}VChNe= z$Pp+>kPHjg3qcmUDD4&zl}br19mpPJM^$Z;bYKGRw%wnke75851L2}I9jy!ITuX>) zeHK+$RA~=)+J8ZDyv<1^aJ0)(r{=%fMVg(nl{CCQrfJ&2h-Yn}|Kf#T1kT<~F zd-z_ne9ce9RxryL*Yb^N`#pKe7*sx;xn}BcnC$kP3rFm z#Vs^23*#_t^d@7lpy;3}%-1Euh;nx}%@-4Z8KAcWhalP~7yTK`^^K19jm24bT(t3@ zP&-CMyXDL7gRf@i{e|B<>8>kdjj(Jn1?@+AFY94MfEef~|`Cd`)8 z3xq6Yi2(q(gTM)aXeNwz_uG{RtX&h=YHZh+GJI4$2&frfvX+7R z+McI%)8S7Y9^h32t#lMsfE6|DlEE-@#&@(#+e*#V92I&eVOep9Gk6;1Gex4lFM#nP zXv!nYBJim`aqJupP!hVG*k^WOgyS#iYg17zTy?8!wDE@HRxLp$yVuiW6FrG18brZL z2Fh^yD?%Ec23eU9y;G{}XSzSPf6DS6xhcWS_5eD2k}QYGv)L2}yi*Xh(Qv%|wYs~7 zkRg2A7_~)CSVtyodZq z(}&&1q?V}wFWL!%mRa2Oj3oN_=AP=3jQA8C+eX|&;6ydBg2#)-IzHkh+d}15lsQA; z?vGD2g~nH_MMDNDZ!V^7-0}Ut$IVb)CJT?xoax7B&cy!j73b%4K{G>rhyOcn@NXgX zAMC>P7;)+DpUD0bpx*^Ncw~BVPCLJ2AUW<3$c9nm5TZZub0pAN210{Ceuya(Q@?)w zoSuMOOt&boLwSCb#TMJK7c^q&QU_;?$Ox9V`hObz%Sga?5XHrbQyyoXX$IUQ5GV?V3GkURSv!I)=eN?mGjXNE^OF$e$IpL%!1XxhKVzR zbJ4m;pR3LATflj3Bh7LI4VE_8wSohPG`rFWFx@5+ynH~X7AWjOmHN`2<#zyFsF4`i z0Z~u#R8R2(+8SpSx9?}rw00v7v-_^YIXi@>>m4Lz+Rf}o7)nLoJ&F90WIGqd)hsM{ zP6io`c=%KE8w(bo^78GaWWDMT{O&18Z(;pBog`v>R#Y-@=vS1L=}ld8ir|*^FX$3Y zQ#MX?3L*^emSfha`X}M`evb#q95KhWss%KfJPa$V^3`%N`lxOq5ceX$A~;!clZc@X z5R)C7j`MAUE>k~~xwo>ah#=r>&y22AIC6i|Qa$1XQZZB4z6(SSL^C}ba6NJ;ikQyL zGMocP3oCgfz~Spetct;nxCb}69-E6NX)gE4fzcq|NcvV8Ksn2R2bsHzm%U?96MqcQ z8!K}bv5<_z$sA3phU)s971vJC=hdmh!#{t`$e^dVPHd-}Pgx#QI0b~(=yB|&pD5Z7 zFWUdAcMCGTH*8E;e9OacSADttL}sIeAD-HXk|3fV%1H$xhmV86gI6LbR@o=ETks2@ z>jQBy?Fzku_l^yf-4;oqi-R$w#T#($l}brZ(eV#POO8?!e&T2DzWND!{qM-vzxM2Z zk`&e4brj~3KRkyJ|-cZ1c=rdz(I{2YgWXTwH+zXRd^SdyhCUA0@enIB{EkSrP(b3i8Fl zpY8kGaAH3Pu%;LxkCRBUvks42B$xtnl5+GjC18dbndHk;j?4=1Ng0arN1?^?iEA8Y zcRa-sUw!w^GhGbm0BeTQTxO!r-42t#%)D(H5 z;p6iLh5+gWMPAc+gF1|Q(kXMFYNew_YSNQA=MrK}hf}$*6+f?aBFrNv!)|Ie#aKyR zHsK|k@(3$7>2PN7J&)o1!o6>r^&&0Az;6&?V^@vw7NN=YmPfmxy0<8@3Vf`=5 zh;JZ9(-K56DHbTB)(n>B_N(>VPK+pP#wdu8!)t3zFVx7R>!=%;(x;Ivp=c?hD`HLs zqjC8|f^jZgqVv?K5)Vn|$O`qsmZ>>wbMpq7H3I5t?($00>2*v^0<<&9Y$PeQ^69>7 zvn3m0!h<@#bEzU~pf@QNBkWm@9m%!VyIRAYqp6Ehznj((CBz$ZSfCA!>rd$(lEZ!f zn3PtnVX06-I10UN8=29Hda~?Q)Hi0*F|02f(yO!)MW33Vil;;;%`GB@G8ZtdA%?4$ zAI_N%**611iS8SO;Z&k)uf8qeC2fr!xMotIAeiHt-X%pClljBu2x}}&3FI==aRK%i zRVRv+en&ghTZJtfIgjRie50CjVXRY+}e$IAjeB`z;vy#51uer2Yx6w)u{VaFPl(p%ws56WB_~r^7z!DJvpr9H(w8D#N3F>+EUW^ zG7(a0hV^afYY_&?LHexeIL^e+ZBh1^)A>giZlwiex@#yG&!71l z%qyq4Tw5AM>fm55i&nqrz{3QvZ$~8v36$uOq|Zy!BYD!5LcSHyJ-7q87#R217}ay? z@yXZBVdx6)ldE_u2&jbc5Y?{~1XniQ;aF7E(eMrU#7ioe(CVGkC8zBI{sE7%~!uX0!@>3zv^j}O&;rWgMy^}BV*db z9Z|NxUR-kgyhR{*WuJg3!ODCPal&78?3fvJnQW_YBOcp9;*X=gfxHY=_AB1@TprxVZtHRg%LYrUaRg+#5|LOZ1iXYuG#kL zCq~eqn}pA&ccXqQ?}i3={P`t(zfHGW8A7$e=dR01)2s1|c{ivRx=FcR0`Et9jc$U8 zlVbd`&Y<#~?&x)Zp5(dw?ZZv;1X&nFou^S4%DxWI#e>D&h|fS>huIXLyR71DIlaEb z&7h2;U!UM=2&JqVXO`41FF&@N?Z&E6|4y(%JRn$s$nHL66?0nSC5jalfAYcf}zpI}m^Qc^YMX3|Q*{?c;bjW*J_Nc^Qn*;0+=|zo&+_-hVs<_y4FiZeU-H;##yUufM-`F_|`U>`!fz zoB>kWRm)X&otSVJpH^oGa2g8j+=Cu_V$!B3lIZrvK8O}$E0Po#m z+uk`gXauW5)qnGlxXpLs&=muZBiaTAyX=1%0S<=&QscZriN}W=PLX##_M7eI?Pz<+ zYQD9GsOwk3eT4%1q$E{eoF2I@9lmGKGU1fWR)|Iio%{+|oHY^?Y7#VpA(Be$nGmQ_N1sy9xpyJ&|oI6i4cecVGSPebcS@&ids65Dr#Ur*>& zrzX=O1{>eV-N7u=B1r4MUgipLJ>WLRYZE;pe>`5>_k*Xm^Kn7{zFs=c@4EPtx5p8A zw)Uz9f+O5n+f4V^lJQgL`!a-2BnLG2$mcxoTALLNj|hSuqJe`e&`w=P>6AI@YPs6N zxo}(oC$|NN;fUNg{#^4bhytv@u$wYmrpgFQq^7cgKPHZk6Lzk7PbE`8Rsl$stN16P z@+PrFR)y^5K55-!+5%685$4UJ2BJVk(h+jM9@g$VcQz#@?__U}<{Sk&DlP%-gy?W< z=sivSq;FPYNi(O` z5HEqY$GWbRrxmQ0==N~A9?&<F_j%2W3=4!$TnmYqE#YOX1Y|PG#iTJ>ljw-iK%Akl7$?#+}$Gn99fBPc+Yz}>~*#0XuWBiWE5OPd$;50Ytdgro83^flX4-+Y)J71fIEKeNGw zBr+5C^rJ#(s5;=j4kY8oMcO_iy4z5veevksijBXuKP9?{CVhqByJ9OZ@!hT#4tsd? zSiD9(-hlU;-|vT!dv}pKl#p&Ohc+W;S;%6N`qBum-l>S3&LXyG2fN- z!Wp=`hPH}Jw2f_zP~Qcvl3(m(y`nk~<2*ILd~r@JqLiuP8U2o_$LxXfP}K&0W6OiR zd5A!qnle+Ayj3oTmME25%W#Q{?L*Bhf1`U2AzNZ)%p}s3eOrWD5i`TTdL`v%9hL9~ zCd`KRvxGBTAM2?~WxaFZ(lP#+s9gfv&H;Tx=X@-|`HI9PPPO@`SIEF+;q6nVA#Q*6 zvyoPPGsFYyfb^!i>7;5GApS}%{esoQap&je_B@xuwhXM5sp=~G;aE;yP#;2d<3em- zEbDnS>6%zcFz~vKu2fEDL84Mc65jMkZ@dD~wHy&ZnG&X_30WVh%jH{Lx3oYT0^^5h zRQiL+MKT-wqY3zn}!{jhC_iqCBb z(86TZ7Vq_QRVvZf!`i}rasWX_Dw(cgW`w0fH9{yp1m-A37}LV40F9wWY-%W0b`qm&KyLR?{4&M8XH zQ7kQFfez>`KIsi2eno5^dr`ye`UCS4#G-qHqp&JrdA6p}B_00Qm~++`Hv+9^!-ghp z3iFmqT>IPu$y@lxthe|R_m4`fAp64&y^C)va4I`k`Ox5UdHxx)N;s;kS|6*+)5O~O z*5|&5r4_eS*7qDN6+E6d0Rxk3ic_&tU%U_GgTgwuJpvIS%f?;41o|x_MzmbQg=NS+pUb)3e|5WOmax^E z3q;OUcWs&dx-X&Y?5A8xetLg7s*si#2cGQCBevsC;J#>5fT)4KU>rkIh9KCGac`j znyYHBzbxub^4wrJKu>n-SO6bmZxT5c6lh4@X+>!}#@TQzvcwOJf05oRd|=(n=XDHs zgngh~DqT{EH$-*tWVSl=*gZJ}e(NdwgV1Bvtq1)lY6Z$A4I#(-TMu`m(3{e#{68k^ zoQe%=0-<3)^KP8NoXQN-`P7yPnB%AbhdAcHF~{*40!OyL?M>T$vvcG}c}S1&;&wDl z1l!v^LB(u+ecg-qdSq&vAEWG7j9$2BZ_+^Vx7DAIy)&&zJG|*ie?sanp5{;Ah-2Vd zke6N(?!^dsG_W^oo4oG)F3HT}j-I&PFKE7b~BIqW-8;GhOz{dDRp|+9(9l9nS!v*0QBg}tzE+rvawlW zj+@M)%>;o3*)R7{PuxeSk7oDOg?&@IhQTM%2{&-;OSfDqUeH4<7(i9ZFH4v;NTero7PZXYg20xjZGYt&I3C>tzg2z?5 zVcq+FMRyRn`ykO33$Oh~sW%_ER$XhX#;9i;_uXz>l#pRKpHh8+{?K(u+vOHrn&V<8 z+F8f6o;Sg_S?=g*C|c773TYU{a>$`ENfH|z;jM+v6WTplc8r3iEeoP?7V;+&w>-6c zbwZ3!F&%IkZz-Zt(^RKaTf6O2*ZiFJ?c-2h1cWcTS)?-_G6$GqJTm&p;hCXjM;TNs zhISR#h3?gp6bs~fxj*_u&IeW=Y8g){wqNOFo3#-k>Uhi>p&~qBjp8$ifS(x?aX4w1 zNkR|hXqK5q@u9hUx&5lt(;!7PzM=4=kQI4>(;)BOqV`y(YqMN z)-tR}C)uciq1>GtxghGhn(`lGY`7|6l?s< z8AG;RHz)>p>JtGY^j|&o-yZmHw&(A=^YYtLz%fjo5wr>#ux3vTWxSW-G_3*E(p|rH z{9ELgZlNHaqHe22n>!}VwQZyyUO9;pBpGT&+O)Fs5QCdK3rZa;o0>u?sTw@`lUD5~ zJ8%$=Enz4{sUBIt{o+(^iojREeNSLl{3K|z7FkjGl|_RoPjTDeQ!Z-B>wdm_gRJ@t zB)yubCL67F3UXG`E!^0+!qXBDrU5_hRkNy4A=DVg_C|4hI;dn5yzg+_3+9c}w}s~B zs$*f$rIolL_5MKXx7%Byj_5WIP_(8ODOzM=dT8s?l=~APJ^2`OmPnj(;fC?12O!JN z;n26)ukq9UhuOP&{HR9aBdaexvVDS?FOQkcYOzIbiRl>5kmb!YFWfUXjqxMc>Sd}1*`%Ic&(IR!` zuhPZLKERkUdFw{9DEzi_5d||ygjt4x)QF@muamSO+X{7pD>l5!K^3VZHn?Y)QBpji z<3(Kr?%X?w#^V5R8Nc)~!mk@>$JIjQ#emBuDGD4M*TvrbhbqV4?4ac<%_$QIVV*)t zpe-e<1jU6eMV4 zRFk#wZ4A#@dd+FfsN)jxCDzMSTxUukcPt9ygtb^LAmwYp$8JIcR+W3c?!4k-iO`Mi z+z#QVdCuz0cD^IwLn}!(DXlgENx_-s@*}1C({C9yWh{hxa`1fX5p9*GM>Rt8O$1&K zl^{GLK@-_*QsPsWmkhMBCR6($l?>f&JJ7eNQs)_{2?}~SW4ABMUuiBReJibC+39*k zbRaF*xx^S^qN-U;*gCSmSE}`>E}r89Syqn%^Xx~#ZQcQe)Px-PMTFG>f=Kh|l$Ko? z9t~w11pDIHdx||a{AjG*@zMloK}yx)GD}!93mN_f!!HqEIu9|5e(p9|LMkKDblkqg z(@RV|+;ywuE-m(mDPF3drtgkcd<#V-r^zET`tHqxr1%Q4SEDTboA#)hp95l?Z8O=b zqu%s-%pD0=x*Z70a{7znAu#994?D4SB;?WFnvDr6-O$^3`3bCtj$?qbn06J?j(Z@; z9U0zI9|XOh-jd?-8D%Fzcl)LxhO_0d|5bTk1a(2a_De+ml-=yD*-ZBZ5-mGX@sgLX zBX%C%3^j1|DRkZo4x*%EOw1+aZ#Mvzb$6*#TRS8&8qG8fuC!EEwZl9#_8-U)NWdW(xa_c>KmK4iv35%M`X;Hxw`&nG`<1>Wl<`zS);_|gm{ zPc8QBrJHD}@kpdOs$c0UfVlBq@#-cyEaNmUavMntqq~{jSEgZGtUp_z&J)(AspexhlJ=MEW_7vHqzHn4hyk@Ub~nM z3{eV4Sdv}VlWug+3PC#_tzhrAOhjtP47r48bqW27*6rIIE8S4KF2gH@)lz%<+jlvb zhz<$sA*U+WPDZnM`9-79RYIZ%OKxYTs_e_QgYT}(z$MYNs z)QLRUD-*hLweYa`J$e6d zC-IF)s~Y92NZv?yyytQ}-2H9r+>taN2;QxLE?Ik#xjxqolDA91oN^ns8nyK{_Oeqp zVdIT{IOq|Pw$p4O37uXv$!i|LE?9)z?Wfh~KoMeB_fIsl3^NS*a@l0whQq1W*0UFn zChrO(sYz=F;**C0T&lijLp?2q2l4<#{b7o~c$lEufe7Bf7F{N$m}}f~j-%&0uCF=_sq|%JWF<+x_|d*FB&V(V1|*2lWQ09VYNw^4uvT~9c~J#!__R`zu~Z*` zgnZMb*W6l}FRP^IAa?$PcaF06TUzi&4swgGR?i}`VU2r?S7{fGK;fg1qM%i#Opti< zO)XVE7VSv|boKJLk+aGe*d9Zs=C`>FMz#2{ zx8RT=Q>z|%hR6q@5h2fBqIR7~NZUNEPSrIXB0$K=owG6hS{+7+Tidwlr9aHz4Ml*@ zHdVg;bX%ee|4aCo6=5kdg;ZWa0>!;p)&1CxiTUxW0U^J~EXtMD38m)rl`RKOA*x3l zr%W`R{PNU9rcPHPxbd6CoC}7Sc!pS-@8@bF~pgX!w z+)^Hvhi5~J)j;b0cwP@wQL;%I@gPteor@n04{&*szq`1BF^uum>mWzdI+n%DG)Eyl z`LH90pXe6hSj_ZT2Nlu#ytj4{r%Mt0ku-})*<2CJP@BQ9+iet#SZYqf7$(ZkKzkw^ z!3*||;I%Lc4)S^#VuBA{b1a6gcy>kt?Q)c0f{zOkUhpr9(e%IS#k7CE5j<7V#6cW& z3gd))uPdN14tNW40cX_z2O$zZN2ra#x2^4;Q~>f7HG#uV=scC0HQNrwSgDWwbgB4z zL{bsM(Xc?eqWCO1CSDIKx7BbeYuDb5hbAx4@3tX91cO09%;iXHOI1@bGi-nQ=g;Gq z*Cls)=Z-%E&bM$9lR=~*VyK)!u6(cpF1?Fge{KH44;!O@c=Swx@dMt1&WlQM=fQL9lDm5 zI31@V*NWa0b1qg>Hd1((KH)ZWX{WZdPTrv$o4j5hDz^tOIvw!jLbV=c={=H%y)$5dcsrGi z0;St5Su6krw-$f8edJBzo;!8)YQu}`{#=%lO?;Z^R_q5SIn51(oD_1;jF3Q;@uAS` zoR(0@wt$cs6~*E#JwgJM9?x#|0d9e<*yerlzJO#y+%2qVQ%Bsjfp%xt`z#EvMxt() znSs|6Nn2(c5;Fr_P;_E%Xl?h(nc1gjxiC%or)U~&td~zextFwHV96TXKqFtBkSp=r zus=_+#h$q*(9Sx$-wJCrqW+Lx`QW8d=}e}Bdx0H;R9wov45^)dbi~yF_^u3%M*-fc zgG8u<`t;$-Ai-F3rh6_|qxG~gy88&pzIGKNjL9XT3h0rG7RjQ>(g<LQ*hZ`x0v%PBxv4Og5ZKk(DyB9RvvL{a_M8VF<|yS<;mIB1OzS!!da=4ubzFBl z5%ym+iiy{;8_a{TnInSsXj-_h;c5?kbiS1?%+1O^Rn!!SD643u$=c&6ypP)-9mE>g zk6wS2m32P|v1cJ1*h0|qi{&m+SWO;XYG1uYw)AL`->N2FgHUMjG?dq>dfJKJI2?m6 zFJ^-8aSB3Up#`Z5yu|jjsZq`&B=d69rW&Oh#LVm{)F&l5QM6A=@*@d1-rB29`S2XS zK80Cs^Y&#hz5%M=6*xKeSJGen28Iu941`T=Z0+Rjb-y>!w{>@$(p#GmVa$_pr4l}+ zMr&*FY2WyTutV%N(mOcv)1X!STO;_xoF6H;nz1HtlK1#1Z;*ea-H_x;?Zf<1$b3BV zX+wY^F)C6@AevNH#c&j$EK+x{;!Ri!v@?uzd|)D*T%fd?)y1`QXTX22>g!); zpgfkFZ!uw4F2_8|nx{3EgUU6pKDwW>0@iHGl;yR>AR8ZK2Wj`_MNi|=(Fj$`^09B#oi@9 zixr=<3ENGq-GwvlnJ=}=AkmUtvJZ5UDKNy4%janbH14)GLy(gmJvJ@pikTUwhxU=I zyji@eVql0x?3hO7oki(aJ@>4ynmQP@TK4!uWI7u{!*amG%_( z!Q}eH!YSHeLo0;14XpbyC198<$fqT(ZiLeB@r#3xfIN!fgfUTumROd%07;zq4$0y5 zK6t0(>1Ewuh~DEn=(=LAycM!)*$bw z249wDj6EUbe%!!NMiVUNLH;%_^f;)KZbdF2D;2aDb+;CmPAEjeV@Z%Img>Hc6B7A= zBLTExY&!!JKNeBSp1D0<9S4ncndG4@4#f9MR~=z>6p+g zEB`IQRv(-&Y#cdynK$n7L?hv#TNESw^Ww^0*NGdS-n?sqp2OFwn#jC2aN3txUFT6( zf2r}3c?=0!Fqt`Ks;YP2Wpk_)Arg;nZi<0x`qN*+cq@83L{p}Xh~_2dFalgSZ6f7% zYy&w3s8v{`T3;p>J#LguzCKfiK*(jRc7quSN;357)~pCA9-`*Eno$CgK!@sk@?-(G zF0&FC=psLK>#7n-85%zdwG)OseN@2_=H*;bQsJ)RLP=$7C8=}IfUf9@gc1$vp@NE2 zS6aY+L!_Y~f_U}(yD#4GVz7=JAM9-U~Xmm}S zdQGqRh5;7X_DMIGu^xHs$~%x%R{h7a$7~I$arAby2z@kZTsg+TCtaEva_)VzEwxh^ z@9xA>F%Nj4IV%AJ71PBg{b^wS?g@Nh1{x*bWI4i%?zTK>y_vyst&EoseR>cCA&|GE z^n=F`6_pK)%zZk~=D!N~HH@_j?E*2yAGdm3=&*Ob365j3AbbZ6IQ^wVhZ#?v~v zcf#-(NmsEpoJx$_jhbS^PANwx2S3(^}Ro^ z_QY{Fn}V_j&9`of=XgB%^d^zQcA74l`AOgH58>QFD_B#Ndmm}sq{0)$o$o$ni@$^~CKkG|YRcis`ToM`BXE zf44;BcWL51$t8C`$VTA%jd)FF|Ie@bUb3_W$#tgrx-wC@wvESj##2>f9jZ*Y(r^pi zp>l~{dAN9E2BPnj?W;Jl7=Zt-)U6l0Z5C#gAIg?^j~ke1bOQn1e`D{w_(=V4H|t;K z89RV|AN|xqoxO@khMMF=9phLYqRE{``|rQ>V_PLHRLl=K9h zM20IOn+4>&cN5!Ke8*(hs;!JnRqpiuL#t(a4Clmlf6_v&Ou$xC&R(yp)XX+%39ZpitwCH zQr3BfX4%%e*Q&TM6vJ%pVv|c#W+&z_Ug>DAd)W}LvB;TMc9XjY*}MXTuMmq5@hmKw@Y~P_Adt};v2E_`s$lLw0r z9v2ajLFB`>)17zVmN+Z99y{`2QiQWOy)d8RvS}N*G=(y)dil9I_NC~uxoey_gw?k? zG(ScVB-V-~26}~%JU+5IVi))5YGd(fmqvEz-C|!8c8_iAZuB9yx&(iv!<^1oq^}yi z*+B`(B8XIjoKpbLI1@+to|xsWSIZbfBAE3QoEUAmhw|V6+&8ZTvm1#`WP6=7R6y|` z{5*d0p7#ef+ae{e#GRe=5Cm>w;Qp@V4xD=a|J8A4EM{Vov2s9_Wnf}pS)-=x9uSAn zQB|x`Q}=fjE*^ufoLvnE-hIkuwK6hwm3U+&16YSBQ`TAFY^_ zFmP`7*JL}4_Xp1mB?`cedG^ciSBB@=Qu3c<5I!j}VIg@1I*9Pk2(d84z(Du?IwOt+ zzMm<<{wW2pVEQRV-S-sVb=d!u@YauXaA#EOzb5=Hqknsu&u`Fw33T=Q9Ip+xyqN$}PZ9!#^dEr0XNG4h z)^9O^b6a*$bMxP$iOk}+HUs64x=^)Kpx>hLKYVC+7DmA8EaodB+`eT%EHl@&1eQTe{YFDX(Pi@!74MJ zQ>APE1=Y7o`>*PPm9;x3>CyQMl0S>w!IlVC2ke{-N&in|KX0kRV#2E9oMQ@^{0Z}W zgM5Sj_Qy{J2$Vb8sub6#@%Z_eL$SFjGJ=a{ok{~Hr@(ft%Q)3CmM=LEw6e?jnbFZKHp zz&cf(6VwD>Aowv#{EcZ6wj{7V3+F_w5f_LqJg$Fw-C*~D&yl;ME+Aign7%>(epeW_ z5U|^C=T!B;0_fj+^8Xl1VYigdVfo_!1pB?i_`?PhYyn^`&*x0uNf(%4r|3V`-G3Aa z)*5 \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >&- +APP_HOME="`pwd -P`" +cd "$SAVED" >&- + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules +function splitJvmOpts() { + JVM_OPTS=("$@") +} +eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS +JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" + +exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat new file mode 100644 index 00000000000..8a0b282aa68 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/gradlew.bat @@ -0,0 +1,90 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windowz variants + +if not "%OS%" == "Windows_NT" goto win9xME_args +if "%@eval[2+2]" == "4" goto 4NT_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* +goto execute + +:4NT_args +@rem Get arguments from the 4NT Shell from JP Software +set CMD_LINE_ARGS=%$ + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt new file mode 100644 index 00000000000..eec86b34406 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/deploy/kotlin/kotlinSrc.kt @@ -0,0 +1,12 @@ +package demo + +import com.google.common.primitives.Ints +import com.google.common.base.Joiner + +class ExampleSource(param : Int) { + val property = param + fun f() : String? { + return "Hello World" + } +} + diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java new file mode 100644 index 00000000000..ec2831d8d21 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/Greeter.java @@ -0,0 +1,17 @@ +package demo; + +/** + * Created by Nikita.Skvortsov + * Date: 3/1/13, 10:53 AM + */ +public class Greeter { + private final String myGreeting; + + public Greeter(String greeting) { + myGreeting = greeting; + } + + public String getGreeting() { + return myGreeting; + } +} diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java new file mode 100644 index 00000000000..2bc6463319b --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/java/demo/HelloWorld.java @@ -0,0 +1,18 @@ +package demo; + +/** + * Created by Nikita.Skvortsov + * Date: 3/1/13, 10:50 AM + */ +public class HelloWorld { + public static void main(String[] args) { + final KotlinGreetingJoiner example = new KotlinGreetingJoiner(new Greeter("Hi")); + + example.addName("Harry"); + example.addName("Ron"); + example.addName(null); + example.addName("Hermione"); + + System.out.println(example.getJoinedGreeting()); + } +} diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt new file mode 100644 index 00000000000..b3e99bbdd59 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/main/kotlin/helloWorld.kt @@ -0,0 +1,20 @@ +package demo + +import com.google.common.primitives.Ints +import com.google.common.base.Joiner +import java.util.ArrayList + +class KotlinGreetingJoiner(val greeter : Greeter) { + + val names = ArrayList() + + fun addName(name : String?): Unit{ + names.add(name) + } + + fun getJoinedGreeting() : String? { + val joiner = Joiner.on(" and ").skipNulls(); + return "${greeter.getGreeting()} ${joiner.join(names)}" + } +} + diff --git a/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt new file mode 100644 index 00000000000..e631927f0ff --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/alfa/src/test/kotlin/tests.kt @@ -0,0 +1,21 @@ +package demo + +import com.google.common.primitives.Ints +import com.google.common.base.Joiner +import org.testng.Assert.* +import org.testng.annotations.AfterMethod +import org.testng.annotations.BeforeMethod +import org.testng.annotations.Test as test + +class TestSource() { + test fun f() { + val example : KotlinGreetingJoiner = KotlinGreetingJoiner(Greeter("Hi")) + example.addName("Harry") + example.addName("Ron") + example.addName(null) + example.addName("Hermione") + + assertEquals(example.getJoinedGreeting(), "Hi Harry and Ron and Hermione") + } +} + From 0514ddc719d50ae79f64749fe4d6e3bc86d02f60 Mon Sep 17 00:00:00 2001 From: Erokhin Stanislav Date: Thu, 30 May 2013 17:09:31 +0400 Subject: [PATCH 77/92] fix Iterable.toSortedList --- libraries/stdlib/src/kotlin/IterablesSpecial.kt | 10 ++++++++++ libraries/stdlib/src/kotlin/JUtil.kt | 2 +- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/libraries/stdlib/src/kotlin/IterablesSpecial.kt b/libraries/stdlib/src/kotlin/IterablesSpecial.kt index 62aff9516be..92abbab4362 100644 --- a/libraries/stdlib/src/kotlin/IterablesSpecial.kt +++ b/libraries/stdlib/src/kotlin/IterablesSpecial.kt @@ -75,3 +75,13 @@ public inline fun Iterable.sort(comparator: java.util.Comparator) : Li java.util.Collections.sort(list, comparator) return list } + +public inline fun Iterable.sort(compare: (T, T) -> Int): List { + return sort( + object : java.util.Comparator { + public override fun compare(o1: T, o2: T): Int { + return compare.invoke(o1, o2) + } + } + ) +} \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/JUtil.kt b/libraries/stdlib/src/kotlin/JUtil.kt index fc015040ae4..400fb43963c 100644 --- a/libraries/stdlib/src/kotlin/JUtil.kt +++ b/libraries/stdlib/src/kotlin/JUtil.kt @@ -27,7 +27,7 @@ public inline fun Collection?.orEmpty() : Collection /** TODO these functions don't work when they generate the Array versions when they are in JLIterables */ public inline fun > Iterable.toSortedList() : List = toCollection(ArrayList()).sort() -public inline fun > Iterable.toSortedList(comparator: java.util.Comparator) : List = toList().sort(comparator) +public inline fun Iterable.toSortedList(compare: (T, T) -> Int) : List = toList().sort(compare) // List APIs From 58914cdf33be43ddb74fb330c673d0ae96f2ac75 Mon Sep 17 00:00:00 2001 From: Maxim Shafirov Date: Thu, 30 May 2013 17:54:27 +0400 Subject: [PATCH 78/92] Delegate properties stdlib, take 2. --- .../src/kotlin/properties/Delegation.kt | 175 ++++++++++++++++++ .../src/kotlin/properties/Properties.kt | 5 +- .../properties/delegation/Delegation.kt | 118 ------------ .../properties/delegation/lazy/LazyValues.kt | 75 -------- .../properties/delegation/DelegationTest.kt | 8 +- .../delegation/MapDelegationTest.kt | 91 ++++----- .../delegation/lazy/LazyValuesTest.kt | 20 +- 7 files changed, 236 insertions(+), 256 deletions(-) create mode 100644 libraries/stdlib/src/kotlin/properties/Delegation.kt delete mode 100644 libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt delete mode 100644 libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt diff --git a/libraries/stdlib/src/kotlin/properties/Delegation.kt b/libraries/stdlib/src/kotlin/properties/Delegation.kt new file mode 100644 index 00000000000..a56b98b2a78 --- /dev/null +++ b/libraries/stdlib/src/kotlin/properties/Delegation.kt @@ -0,0 +1,175 @@ +package kotlin.properties + +public trait ReadOnlyProperty { + public fun get(thisRef: R, desc: PropertyMetadata): T +} + +public trait ReadWriteProperty { + public fun get(thisRef: R, desc: PropertyMetadata): T + public fun set(thisRef: R, desc: PropertyMetadata, value: T) +} + +public object Delegates { + public fun notNull(): ReadWriteProperty = NotNullVar() + + public fun lazy(initializer: () -> T): ReadOnlyProperty = LazyVal(initializer) + public fun blockingLazy(lock: Any? = null, initializer: () -> T): ReadOnlyProperty = BlockingLazyVal(lock, initializer) + + public fun observable(initial: T, onChange: (desc: PropertyMetadata, oldValue: T, newValue: T) -> Unit): ReadWriteProperty { + return ObservableProperty(initial) { (desc, old, new) -> + onChange(desc, old, new) + true + } + } + + public fun vetoable(initial: T, onChange: (desc: PropertyMetadata, oldValue: T, newValue: T) -> Boolean): ReadWriteProperty { + return ObservableProperty(initial, onChange) + } + + public fun mapVar(map: MutableMap, + default: (thisRef: Any?, desc: String) -> T = defaultValueProvider): ReadWriteProperty { + return FixedMapVar(map, defaultKeyProvider, default) + } + + public fun mapVal(map: Map, + default: (thisRef: Any?, desc: String) -> T = defaultValueProvider): ReadOnlyProperty { + return FixedMapVal(map, defaultKeyProvider, default) + } +} + + +private class NotNullVar() : ReadWriteProperty { + private var value: T? = null + + public override fun get(thisRef: Any?, desc: PropertyMetadata): T { + return value ?: throw IllegalStateException("Property ${desc.name} should be initialized before get") + } + + public override fun set(thisRef: Any?, desc: PropertyMetadata, value: T) { + this.value = value + } +} + +class ObservableProperty(initialValue: T, val onChange: (name: jet.PropertyMetadata, oldValue: T, newValue: T) -> Boolean): ReadWriteProperty { + private var value = initialValue + + public override fun get(thisRef: Any?, desc: PropertyMetadata): T { + return value + } + + public override fun set(thisRef: Any?, desc: PropertyMetadata, value: T) { + if (onChange(desc, this.value, value)) { + this.value = value + } + } +} + +private val NULL_VALUE: Any = Any() + +private fun escape(value: Any?): Any { + return value ?: NULL_VALUE +} + +private fun unescape(value: Any?): Any? { + return if (value == NULL_VALUE) null else value +} + +private class LazyVal(private val initializer: () -> T) : ReadOnlyProperty { + private var value: Any? = null + + public override fun get(thisRef: Any?, desc: PropertyMetadata): T { + if (value == null) { + value = escape(initializer()) + } + return unescape(value) as T + } +} + +private class BlockingLazyVal(lock: Any?, private val initializer: () -> T) : ReadOnlyProperty { + private val lock = lock ?: this + private volatile var value: Any? = null + + public override fun get(thisRef: Any?, desc: PropertyMetadata): T { + val _v1 = value + if (_v1 != null) { + return unescape(_v1) as T + } + + return synchronized(lock) { + val _v2 = value + if (_v2 != null) { + unescape(_v2) as T + } + else { + val typedValue = initializer() + value = escape(typedValue) + typedValue + } + } + } +} + +public class KeyMissingException(message: String): RuntimeException(message) + +public abstract class MapVal() : ReadOnlyProperty { + protected abstract fun map(ref: T): Map + protected abstract fun key(desc: PropertyMetadata): K + + protected open fun default(ref: T, desc: PropertyMetadata): V { + throw KeyMissingException("Key $desc is missing in $ref") + } + + public override fun get(thisRef: T, desc: PropertyMetadata) : V { + val map = map(thisRef) + val key = key(desc) + if (!map.containsKey(key)) { + return default(thisRef, desc) + } + + return map[key] as V + } +} + +public abstract class MapVar() : MapVal(), ReadWriteProperty { + protected abstract override fun map(ref: T): MutableMap + + public override fun set(thisRef: T, desc: PropertyMetadata, value: V) { + val map = map(thisRef) + map.put(key(desc), value) + } +} + +private val defaultKeyProvider:(PropertyMetadata) -> String = {it.name} +private val defaultValueProvider:(Any?, Any?) -> Nothing = {(thisRef, key) -> throw KeyMissingException("$key is missing from $thisRef")} + +public open class FixedMapVal(private val map: Map, + private val key: (PropertyMetadata) -> K, + private val default: (ref: T, key: K) -> V = defaultValueProvider) : MapVal() { + protected override fun map(ref: T): Map { + return map + } + + protected override fun key(desc: PropertyMetadata): K { + return (key)(desc) + } + + protected override fun default(ref: T, desc: PropertyMetadata): V { + return (default)(ref, key(desc)) + } +} + +public open class FixedMapVar(private val map: MutableMap, + private val key: (PropertyMetadata) -> K, + private val default: (ref: T, key: K) -> V = defaultValueProvider) : MapVar() { + protected override fun map(ref: T): MutableMap { + return map + } + + protected override fun key(desc: PropertyMetadata): K { + return (key)(desc) + } + + protected override fun default(ref: T, desc: PropertyMetadata): V { + return (default)(ref, key(desc)) + } +} diff --git a/libraries/stdlib/src/kotlin/properties/Properties.kt b/libraries/stdlib/src/kotlin/properties/Properties.kt index e045c5993c6..78dc550e692 100644 --- a/libraries/stdlib/src/kotlin/properties/Properties.kt +++ b/libraries/stdlib/src/kotlin/properties/Properties.kt @@ -2,7 +2,6 @@ package kotlin.properties import java.util.HashMap import java.util.ArrayList -import kotlin.properties.delegation.ObservableProperty public class ChangeEvent(val source: Any, val name: String, val oldValue: Any?, val newValue: Any?) { var propogationId: Any? = null @@ -65,8 +64,8 @@ public abstract class ChangeSupport { } } - protected fun property(init: T): ObservableProperty { - return ObservableProperty(init) { name, oldValue, newValue -> changeProperty(name, oldValue, newValue) } + protected fun property(init: T): ReadWriteProperty { + return Delegates.observable(init) { desc, oldValue, newValue -> changeProperty(desc.name, oldValue, newValue) } } public fun onPropertyChange(fn: (ChangeEvent) -> Unit) { diff --git a/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt b/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt deleted file mode 100644 index fe4dbb05a6d..00000000000 --- a/libraries/stdlib/src/kotlin/properties/delegation/Delegation.kt +++ /dev/null @@ -1,118 +0,0 @@ -package kotlin.properties.delegation - -import kotlin.properties.ChangeSupport - -public class NotNullVar { - private var value: T? = null - - public fun get(thisRef: Any?, desc: PropertyMetadata): T { - return value ?: throw IllegalStateException("Property ${desc.name} should be initialized before get") - } - - public fun set(thisRef: Any?, desc: PropertyMetadata, value: T) { - this.value = value - } -} - -public class SynchronizedVar(private val initValue: T, private val lock: Any) { - private var value: T = initValue - - public fun get(thisRef: Any?, desc: PropertyMetadata): T { - return synchronized(lock) { value } - } - - public fun set(thisRef: Any?, desc: PropertyMetadata, newValue: T) { - synchronized(lock) { - value = newValue - } - } -} - -class ObservableProperty(initialValue: T, val changeSupport: (name: String, oldValue: T, newValue: T) -> Unit) { - private var value = initialValue - - public fun get(thisRef: Any?, desc: PropertyMetadata): T { - return value - } - - public fun set(thisRef: Any?, desc: PropertyMetadata, newValue: T) { - changeSupport(desc.name, value, newValue) - value = newValue - } -} - -public class KeyMissingException(message: String): RuntimeException(message) - -public abstract class MapVal { - public abstract fun getMap(thisRef: T): Map<*, *> - public abstract fun getKey(desc: PropertyMetadata): Any? - - public open fun getDefaultValue(desc: PropertyMetadata, key: Any?): V { - throw KeyMissingException("Key $key is missing") - } - - public fun get(thisRef: T, desc: PropertyMetadata): V { - val key = getKey(desc) - val map = getMap(thisRef) - if (!map.containsKey(key)) { - return getDefaultValue(desc, key) - } - return map[key] as V - } -} - -public abstract class MapVar: MapVal() { - - public fun set(thisRef: T, desc: PropertyMetadata, newValue: V) { - val map = getMap(thisRef) as MutableMap - map[getKey(desc)] = newValue - } -} - -public fun Map.readOnlyProperty(default: (() -> V)? = null): MapVal { - return object: MapVal() { - override fun getMap(thisRef: Any?) = this@readOnlyProperty - override fun getKey(desc: PropertyMetadata) = desc.name - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} - -public fun Map<*, *>.readOnlyProperty(default: (() -> V)? = null, key: Any?): MapVal { - return object: MapVal() { - override fun getMap(thisRef: Any?) = this@readOnlyProperty - override fun getKey(desc: PropertyMetadata) = key - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} - -public fun Map<*, *>.readOnlyProperty(default: (() -> V)? = null, key: (desc: PropertyMetadata) -> Any?): MapVal { - return object: MapVal() { - override fun getMap(thisRef: Any?) = this@readOnlyProperty - override fun getKey(desc: PropertyMetadata) = key(desc) - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} - -public fun MutableMap.property(default: (() -> V)? = null): MapVar { - return object: MapVar() { - override fun getMap(thisRef: Any?) = this@property - override fun getKey(desc: PropertyMetadata) = desc.name - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} - -public fun MutableMap<*, *>.property(default: (() -> V)? = null, key: Any?): MapVar { - return object: MapVar() { - override fun getMap(thisRef: Any?) = this@property - override fun getKey(desc: PropertyMetadata) = key - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} - -public fun MutableMap<*, *>.property(default: (() -> V)? = null, key: (desc: PropertyMetadata) -> Any?): MapVar { - return object: MapVar() { - override fun getMap(thisRef: Any?) = this@property - override fun getKey(desc: PropertyMetadata) = key(desc) - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = if (default == null) super.getDefaultValue(desc, key) else default() - } -} \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt b/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt deleted file mode 100644 index 2d0767446d3..00000000000 --- a/libraries/stdlib/src/kotlin/properties/delegation/lazy/LazyValues.kt +++ /dev/null @@ -1,75 +0,0 @@ -package kotlin.properties.delegation.lazy - -private val NULL_VALUE: Any = Any() - -private fun escape(value: T): Any { - return if (value == null) NULL_VALUE else value -} - -private fun unescape(value: Any): T? { - return if (value == NULL_VALUE) null else value as T -} - -public open class LazyVal(initializer: () -> T): NullableLazyVal(initializer) { - override fun get(thisRef: Any?, desc: PropertyMetadata): T { - return super.get(thisRef, desc)!! - } -} - -public open class NullableLazyVal(private val initializer: () -> T?) { - private var value: Any? = null - - public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { - if (value == null) { - value = escape(initializer()) - } - return unescape(value!!) - } -} - -public open class VolatileLazyVal(initializer: () -> T): VolatileNullableLazyVal(initializer) { - override fun get(thisRef: Any?, desc: PropertyMetadata): T { - return super.get(thisRef, desc)!! - } -} - -public open class VolatileNullableLazyVal(private val initializer: () -> T?) { - private volatile var value: Any? = null - - public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { - if (value == null) { - value = escape(initializer()) - } - return unescape(value!!) - } -} - -public open class AtomicLazyVal(lock: Any? = null, initializer: () -> T): AtomicNullableLazyVal(lock, initializer) { - override fun get(thisRef: Any?, desc: PropertyMetadata): T { - return super.get(thisRef, desc)!! - } -} - -public open class AtomicNullableLazyVal(lock: Any? = null, private val initializer: () -> T?) { - private val lock = lock ?: this - private volatile var value: Any? = null - - public open fun get(thisRef: Any?, desc: PropertyMetadata): T? { - val _v1 = value - if (_v1 != null) { - return unescape(_v1) - } - - return synchronized(lock) { - val _v2 = value - if (_v2 != null) { - unescape(_v2) - } - else { - val typedValue = initializer() - value = escape(typedValue) - typedValue - } - } - } -} \ No newline at end of file diff --git a/libraries/stdlib/test/properties/delegation/DelegationTest.kt b/libraries/stdlib/test/properties/delegation/DelegationTest.kt index cceeeaf6af1..4098956d993 100644 --- a/libraries/stdlib/test/properties/delegation/DelegationTest.kt +++ b/libraries/stdlib/test/properties/delegation/DelegationTest.kt @@ -3,8 +3,6 @@ package test.properties.delegation import junit.framework.TestCase import kotlin.test.* import kotlin.properties.* -import kotlin.properties.delegation.* -import kotlin.properties.delegation.lazy.* trait WithBox { fun box(): String @@ -27,8 +25,8 @@ class DelegationTest(): DelegationTestBase() { } public class TestNotNullVar(val a1: String, val b1: T): WithBox { - var a: String by NotNullVar() - var b by NotNullVar() + var a: String by Delegates.notNull() + var b by Delegates.notNull() override fun box(): String { a = a1 @@ -61,4 +59,4 @@ class TestObservableProperty: WithBox, ChangeSupport() { if (!result) return "fail: result should be true" return "OK" } -} \ No newline at end of file +} diff --git a/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt b/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt index 9bc21c81c20..b6df3fc21fb 100644 --- a/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt +++ b/libraries/stdlib/test/properties/delegation/MapDelegationTest.kt @@ -1,7 +1,7 @@ package test.properties.delegation import java.util.HashMap -import kotlin.properties.delegation.* +import kotlin.properties.* class MapDelegationTest(): DelegationTestBase() { @@ -48,10 +48,10 @@ class MapDelegationTest(): DelegationTestBase() { class TestMapValWithDifferentTypes(): WithBox { val map = hashMapOf("a" to "a", "b" to 1, "c" to A(1), "d" to null) - val a by map.readOnlyProperty() - val b by map.readOnlyProperty() - val c by map.readOnlyProperty() - val d by map.readOnlyProperty() + val a by Delegates.mapVal(map) + val b by Delegates.mapVal(map) + val c by Delegates.mapVal(map) + val d by Delegates.mapVal(map) override fun box(): String { if (a != "a") return "fail at 'a'" @@ -66,10 +66,10 @@ class TestMapValWithDifferentTypes(): WithBox { class TestMapVarWithDifferentTypes(): WithBox { val map: HashMap = hashMapOf("a" to "a", "b" to 1, "c" to A(1), "d" to "d") - var a by map.property() - var b by map.property() - var c by map.property() - var d by map.property() + var a by Delegates.mapVar(map) + var b by Delegates.mapVar(map) + var c by Delegates.mapVar(map) + var d by Delegates.mapVar(map) override fun box(): String { a = "aa" @@ -87,8 +87,8 @@ class TestMapVarWithDifferentTypes(): WithBox { } class TestNullableKey: WithBox { - val map = hashMapOf(null to "null") - var a by map.property { desc -> null } + val map = hashMapOf(null:Any? to "null": Any?) + var a by FixedMapVar(map, key = { desc -> null }, default = {ref, desc -> null}) override fun box(): String { if (a != "null") return "fail at 'a'" @@ -99,10 +99,10 @@ class TestNullableKey: WithBox { } class TestMapPropertyString(): WithBox { - val map = hashMapOf("a" to "a", "b" to "b", "c" to "c") - val a by map.readOnlyProperty() - var b by map.property() - val c by map.property() + val map = hashMapOf("a" to "a", "b" to "b", "c" to "c":Any?) + val a by Delegates.mapVal(map) + var b by Delegates.mapVar(map) + val c by Delegates.mapVal(map) override fun box(): String { b = "newB" @@ -115,9 +115,9 @@ class TestMapPropertyString(): WithBox { class TestMapValWithDefault(): WithBox { val map = hashMapOf() - val a by map.readOnlyProperty(default = { "aDefault" }) - val b by map.readOnlyProperty(default = { "bDefault" }, key = "b") - val c by map.readOnlyProperty(default = { "cDefault" }, key = { desc -> desc.name }) + val a by Delegates.mapVal(map, default = { ref, desc -> "aDefault" }) + val b by FixedMapVal(map, default = { ref, desc -> "bDefault" }, key = {"b"}) + val c by FixedMapVal(map, default = { ref, desc -> "cDefault" }, key = { desc -> desc.name }) override fun box(): String { if (a != "aDefault") return "fail at 'a'" @@ -128,10 +128,10 @@ class TestMapValWithDefault(): WithBox { } class TestMapVarWithDefault(): WithBox { - val map = hashMapOf() - var a by map.property(default = { "aDefault" }) - var b by map.property(default = { "bDefault" }, key = "b") - var c by map.property(default = { "cDefault" }, key = { desc -> desc.name }) + val map = hashMapOf() + var a: String by Delegates.mapVar(map, default = {ref, desc -> "aDefault" }) + var b: String by FixedMapVar(map, default = {ref, desc -> "bDefault" }, key = {"b"}) + var c: String by FixedMapVar(map, default = {ref, desc -> "cDefault" }, key = { desc -> desc.name }) override fun box(): String { if (a != "aDefault") return "fail at 'a'" @@ -148,9 +148,9 @@ class TestMapVarWithDefault(): WithBox { } class TestMapPropertyKey(): WithBox { - val map = hashMapOf("a" to "a", "b" to "b") - val a by map.readOnlyProperty(key = "a") - var b by map.property(key = "b") + val map = hashMapOf("a" to "a", "b" to "b" : Any?) + val a by FixedMapVal(map, key = {"a"}) + var b by FixedMapVar(map, key = {"b"}) override fun box(): String { b = "c" @@ -161,9 +161,9 @@ class TestMapPropertyKey(): WithBox { } class TestMapPropertyFunction(): WithBox { - val map = hashMapOf("aDesc" to "a", "bDesc" to "b") - val a by map.readOnlyProperty { desc -> "${desc.name}Desc" } - var b by map.property { desc -> "${desc.name}Desc" } + val map = hashMapOf("aDesc" to "a", "bDesc" to "b": Any?) + val a by FixedMapVal(map, { desc -> "${desc.name}Desc" }) + var b by FixedMapVar(map, { desc -> "${desc.name}Desc" }) override fun box(): String { b = "c" @@ -173,17 +173,18 @@ class TestMapPropertyFunction(): WithBox { } } -val mapVal = object : MapVal() { - override fun getMap(thisRef: TestMapPropertyCustom) = thisRef.map - override fun getKey(desc: PropertyMetadata) = "${desc.name}Desc" +val mapVal = object: MapVal() { + override fun map(ref: TestMapPropertyCustom) = ref.map + override fun key(desc: PropertyMetadata) = "${desc.name}Desc" } -val mapVar = object : MapVar() { - override fun getMap(thisRef: TestMapPropertyCustom) = thisRef.map - override fun getKey(desc: PropertyMetadata) = "${desc.name}Desc" + +val mapVar = object : MapVar() { + override fun map(ref: TestMapPropertyCustom) = ref.map + override fun key(desc: PropertyMetadata) = "${desc.name}Desc" } class TestMapPropertyCustom(): WithBox { - val map = hashMapOf("aDesc" to "a", "bDesc" to "b") + val map = hashMapOf("aDesc" to "a", "bDesc" to "b":Any?) val a by mapVal var b by mapVar @@ -195,22 +196,22 @@ class TestMapPropertyCustom(): WithBox { } } -val mapValWithDefault = object : MapVal() { - override fun getMap(thisRef: TestMapPropertyCustomWithDefault) = thisRef.map - override fun getKey(desc: PropertyMetadata) = desc.name +val mapValWithDefault = object : MapVal() { + override fun map(ref: TestMapPropertyCustomWithDefault) = ref.map + override fun key(desc: PropertyMetadata) = desc.name - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = "default" + override fun default(ref: TestMapPropertyCustomWithDefault, key: PropertyMetadata) = "default" } -val mapVarWithDefault = object : MapVar() { - override fun getMap(thisRef: TestMapPropertyCustomWithDefault) = thisRef.map - override fun getKey(desc: PropertyMetadata) = desc.name +val mapVarWithDefault = object : MapVar() { + override fun map(ref: TestMapPropertyCustomWithDefault) = ref.map + override fun key(desc: PropertyMetadata) = desc.name - override fun getDefaultValue(desc: PropertyMetadata, key: Any?) = "default" + override fun default(ref: TestMapPropertyCustomWithDefault, key: PropertyMetadata) = "default" } class TestMapPropertyCustomWithDefault(): WithBox { - val map = hashMapOf() + val map = hashMapOf() val a by mapValWithDefault var b by mapVarWithDefault @@ -221,4 +222,4 @@ class TestMapPropertyCustomWithDefault(): WithBox { if (b != "c") return "fail at 'b' after set" return "OK" } -} \ No newline at end of file +} diff --git a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt index 6a3a4cac847..31fe609bf2d 100644 --- a/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt +++ b/libraries/stdlib/test/properties/delegation/lazy/LazyValuesTest.kt @@ -1,8 +1,8 @@ package test.properties.delegation.lazy -import kotlin.properties.delegation.lazy.* import test.properties.delegation.WithBox import test.properties.delegation.DelegationTestBase +import kotlin.properties.* class LazyValuesTest(): DelegationTestBase() { @@ -33,7 +33,7 @@ class LazyValuesTest(): DelegationTestBase() { class TestLazyVal: WithBox { var result = 0 - val a by LazyVal { + val a by Delegates.lazy { ++result } @@ -48,8 +48,8 @@ class TestNullableLazyVal: WithBox { var resultA = 0 var resultB = 0 - val a: Int? by NullableLazyVal { resultA++; null} - val b by NullableLazyVal { foo() } + val a: Int? by Delegates.lazy { resultA++; null} + val b by Delegates.lazy { foo() } override fun box(): String { a @@ -70,7 +70,7 @@ class TestNullableLazyVal: WithBox { class TestAtomicLazyVal: WithBox { var result = 0 - val a by AtomicLazyVal { + val a by Delegates.blockingLazy { ++result } @@ -85,8 +85,8 @@ class TestVolatileNullableLazyVal: WithBox { var resultA = 0 var resultB = 0 - val a: Int? by VolatileNullableLazyVal { resultA++; null} - val b by VolatileNullableLazyVal { foo() } + val a: Int? by Delegates.blockingLazy { resultA++; null} + val b by Delegates.blockingLazy { foo() } override fun box(): String { a @@ -107,7 +107,7 @@ class TestVolatileNullableLazyVal: WithBox { class TestVolatileLazyVal: WithBox { var result = 0 - val a by VolatileLazyVal { + val a by Delegates.blockingLazy { ++result } @@ -122,8 +122,8 @@ class TestAtomicNullableLazyVal: WithBox { var resultA = 0 var resultB = 0 - val a: Int? by AtomicNullableLazyVal { resultA++; null} - val b by AtomicNullableLazyVal { foo() } + val a: Int? by Delegates.blockingLazy { resultA++; null} + val b by Delegates.blockingLazy { foo() } override fun box(): String { a From 868bf90de226bf8e4828bbfb7c24a462f5cf1007 Mon Sep 17 00:00:00 2001 From: Maxim Shafirov Date: Fri, 31 May 2013 11:35:11 +0400 Subject: [PATCH 79/92] Rollback 0514ddc719d50ae79f64749fe4d6e3bc86d02f60 due to failing tests --- libraries/stdlib/src/kotlin/IterablesSpecial.kt | 10 ---------- libraries/stdlib/src/kotlin/JUtil.kt | 2 +- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/libraries/stdlib/src/kotlin/IterablesSpecial.kt b/libraries/stdlib/src/kotlin/IterablesSpecial.kt index 92abbab4362..62aff9516be 100644 --- a/libraries/stdlib/src/kotlin/IterablesSpecial.kt +++ b/libraries/stdlib/src/kotlin/IterablesSpecial.kt @@ -75,13 +75,3 @@ public inline fun Iterable.sort(comparator: java.util.Comparator) : Li java.util.Collections.sort(list, comparator) return list } - -public inline fun Iterable.sort(compare: (T, T) -> Int): List { - return sort( - object : java.util.Comparator { - public override fun compare(o1: T, o2: T): Int { - return compare.invoke(o1, o2) - } - } - ) -} \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/JUtil.kt b/libraries/stdlib/src/kotlin/JUtil.kt index 400fb43963c..fc015040ae4 100644 --- a/libraries/stdlib/src/kotlin/JUtil.kt +++ b/libraries/stdlib/src/kotlin/JUtil.kt @@ -27,7 +27,7 @@ public inline fun Collection?.orEmpty() : Collection /** TODO these functions don't work when they generate the Array versions when they are in JLIterables */ public inline fun > Iterable.toSortedList() : List = toCollection(ArrayList()).sort() -public inline fun Iterable.toSortedList(compare: (T, T) -> Int) : List = toList().sort(compare) +public inline fun > Iterable.toSortedList(comparator: java.util.Comparator) : List = toList().sort(comparator) // List APIs From f05f616230ed0d61a2777b94e3de047774a092d2 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 22 May 2013 16:40:29 +0400 Subject: [PATCH 80/92] KT-2422 Invalid warning "Condition is always true" #KT-2422 fixed --- .../calls/autocasts/DataFlowValueFactory.java | 170 ++++++++++++++---- .../diagnostics/tests/smartCasts/kt2422.kt | 23 +++ .../noErrorCheckForPackageLevelVal.kt | 25 +++ .../tests/smartCasts/thisWithLabel.kt | 36 ++++ .../smartCasts/thisWithLabelAsReceiverPart.kt | 39 ++++ .../checkers/JetDiagnosticsTestGenerated.java | 20 +++ 6 files changed, 280 insertions(+), 33 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/smartCasts/kt2422.kt create mode 100644 compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt create mode 100644 compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt create mode 100644 compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index b1edec00e93..d8793b33b33 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -18,17 +18,20 @@ package org.jetbrains.jet.lang.resolve.calls.autocasts; import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetNodeTypes; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.JetModuleUtil; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.scopes.receivers.*; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; +import static org.jetbrains.jet.lang.resolve.BindingContext.RESOLVED_CALL; public class DataFlowValueFactory { public static final DataFlowValueFactory INSTANCE = new DataFlowValueFactory(); @@ -42,8 +45,8 @@ public class DataFlowValueFactory { if (constantExpression.getNode().getElementType() == JetNodeTypes.NULL) return DataFlowValue.NULL; } if (TypeUtils.equalTypes(type, KotlinBuiltIns.getInstance().getNullableNothingType())) return DataFlowValue.NULL; // 'null' is the only inhabitant of 'Nothing?' - Pair result = getIdForStableIdentifier(expression, bindingContext, false); - return new DataFlowValue(result.first == null ? expression : result.first, type, result.second, getImmanentNullability(type)); + IdentifierInfo result = getIdForStableIdentifier(expression, bindingContext, false); + return new DataFlowValue(result.id == null ? expression : result.id, type, result.isStable, getImmanentNullability(type)); } @NotNull @@ -104,55 +107,156 @@ public class DataFlowValueFactory { return type.isNullable() || TypeUtils.hasNullableSuperType(type) ? Nullability.UNKNOWN : Nullability.NOT_NULL; } + private static class IdentifierInfo { + public final Object id; + public final boolean isStable; + public final boolean isNamespace; + + private IdentifierInfo(Object id, boolean isStable, boolean isNamespace) { + this.id = id; + this.isStable = isStable; + this.isNamespace = isNamespace; + } + } + + private static final IdentifierInfo ERROR_IDENTIFIER_INFO = new IdentifierInfo(null, false, false); + @NotNull - private static Pair getIdForStableIdentifier(@NotNull JetExpression expression, @NotNull BindingContext bindingContext, boolean allowNamespaces) { + private static IdentifierInfo createInfo(Object id, boolean isStable) { + return new IdentifierInfo(id, isStable, false); + } + + @NotNull + private static IdentifierInfo createNamespaceInfo(Object id, boolean isStable) { + return new IdentifierInfo(id, isStable, true); + } + + @NotNull + private static IdentifierInfo combineInfo(@Nullable IdentifierInfo receiverInfo, @NotNull IdentifierInfo selectorInfo) { + if (receiverInfo == null || receiverInfo == ERROR_IDENTIFIER_INFO || receiverInfo.isNamespace) { + return selectorInfo; + } + return createInfo(Pair.create(receiverInfo.id, selectorInfo.id), receiverInfo.isStable && selectorInfo.isStable); + } + + @NotNull + private static IdentifierInfo getIdForStableIdentifier( + @Nullable JetExpression expression, + @NotNull BindingContext bindingContext, + boolean allowNamespaces + ) { if (expression instanceof JetParenthesizedExpression) { JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) expression; JetExpression innerExpression = parenthesizedExpression.getExpression(); - if (innerExpression == null) { - return Pair.create(null, false); - } + return getIdForStableIdentifier(innerExpression, bindingContext, allowNamespaces); } else if (expression instanceof JetQualifiedExpression) { JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) expression; + JetExpression receiverExpression = qualifiedExpression.getReceiverExpression(); JetExpression selectorExpression = qualifiedExpression.getSelectorExpression(); - if (selectorExpression == null) { - return Pair.create(null, false); - } - Pair receiverId = getIdForStableIdentifier(qualifiedExpression.getReceiverExpression(), bindingContext, true); - Pair selectorId = getIdForStableIdentifier(selectorExpression, bindingContext, allowNamespaces); - return receiverId.second ? selectorId : Pair.create(receiverId.first, false); + IdentifierInfo receiverId = getIdForStableIdentifier(receiverExpression, bindingContext, true); + IdentifierInfo selectorId = getIdForStableIdentifier(selectorExpression, bindingContext, allowNamespaces); + + return combineInfo(receiverId, selectorId); } if (expression instanceof JetSimpleNameExpression) { - JetSimpleNameExpression simpleNameExpression = (JetSimpleNameExpression) expression; - DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, simpleNameExpression); - if (declarationDescriptor instanceof VariableDescriptor) { - return Pair.create((Object) declarationDescriptor, isStableVariable((VariableDescriptor) declarationDescriptor)); - } - if (declarationDescriptor instanceof NamespaceDescriptor) { - return Pair.create((Object) declarationDescriptor, allowNamespaces); - } - if (declarationDescriptor instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; - return Pair.create((Object) classDescriptor, classDescriptor.isClassObjectAValue()); - } + return getIdForSimpleNameExpression((JetSimpleNameExpression) expression, bindingContext, allowNamespaces); } else if (expression instanceof JetThisExpression) { JetThisExpression thisExpression = (JetThisExpression) expression; DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, thisExpression.getInstanceReference()); - if (declarationDescriptor instanceof CallableDescriptor) { - return Pair.create((Object) ((CallableDescriptor) declarationDescriptor).getReceiverParameter().getValue(), true); - } - if (declarationDescriptor instanceof ClassDescriptor) { - return Pair.create((Object) ((ClassDescriptor) declarationDescriptor).getThisAsReceiverParameter().getValue(), true); - } - return Pair.create(null, true); + + return getIdForThisReceiver(declarationDescriptor); } else if (expression instanceof JetRootNamespaceExpression) { - return Pair.create((Object) JetModuleUtil.getRootNamespaceType(expression), allowNamespaces); + return createNamespaceInfo(JetModuleUtil.getRootNamespaceType(expression), allowNamespaces); } - return Pair.create(null, false); + return ERROR_IDENTIFIER_INFO; + } + + @NotNull + private static IdentifierInfo getIdForSimpleNameExpression( + @NotNull JetSimpleNameExpression simpleNameExpression, + @NotNull BindingContext bindingContext, + boolean allowNamespaces + ) { + DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, simpleNameExpression); + if (declarationDescriptor instanceof VariableDescriptor) { + ResolvedCall resolvedCall = bindingContext.get(RESOLVED_CALL, simpleNameExpression); + // todo return assert + // for now it fails for resolving 'invoke' convention, return it after 'invoke' algorithm changes + // assert resolvedCall != null : "Cannot create right identifier info if the resolved call is not known yet for " + declarationDescriptor; + + IdentifierInfo receiverInfo = resolvedCall != null ? getIdForImplicitReceiver(resolvedCall.getThisObject(), simpleNameExpression) : null; + + VariableDescriptor variableDescriptor = (VariableDescriptor) declarationDescriptor; + return combineInfo(receiverInfo, createInfo(variableDescriptor, isStableVariable(variableDescriptor))); + } + if (declarationDescriptor instanceof NamespaceDescriptor) { + return createNamespaceInfo(declarationDescriptor, allowNamespaces); + } + if (declarationDescriptor instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; + return createInfo(classDescriptor, classDescriptor.isClassObjectAValue()); + } + return ERROR_IDENTIFIER_INFO; + } + + @Nullable + private static IdentifierInfo getIdForImplicitReceiver(@NotNull ReceiverValue receiverValue, @Nullable final JetExpression expression) { + return receiverValue.accept(new ReceiverValueVisitor() { + + @Override + public IdentifierInfo visitNoReceiver(ReceiverValue noReceiver, Void data) { + return null; + } + + @Override + public IdentifierInfo visitTransientReceiver(TransientReceiver receiver, Void data) { + assert false: "Transient receiver is implicit for an explicit expression: " + expression + ". Receiver: " + receiver; + return null; + } + + @Override + public IdentifierInfo visitExtensionReceiver(ExtensionReceiver receiver, Void data) { + return getIdForThisReceiver(receiver); + } + + @Override + public IdentifierInfo visitExpressionReceiver(ExpressionReceiver receiver, Void data) { + // there is an explicit "this" expression and it was analyzed earlier + return null; + } + + @Override + public IdentifierInfo visitClassReceiver(ClassReceiver receiver, Void data) { + return getIdForThisReceiver(receiver); + } + + @Override + public IdentifierInfo visitScriptReceiver(ScriptReceiver receiver, Void data) { + return getIdForThisReceiver(receiver); + } + }, null); + } + + @NotNull + private static IdentifierInfo getIdForThisReceiver(@NotNull ThisReceiver thisReceiver) { + return getIdForThisReceiver(thisReceiver.getDeclarationDescriptor()); + } + + @NotNull + private static IdentifierInfo getIdForThisReceiver(@Nullable DeclarationDescriptor descriptorOfThisReceiver) { + if (descriptorOfThisReceiver instanceof CallableDescriptor) { + ReceiverParameterDescriptor receiverParameter = ((CallableDescriptor) descriptorOfThisReceiver).getReceiverParameter(); + assert receiverParameter != null : "'This' refers to the callable member without a receiver parameter: " + descriptorOfThisReceiver; + return createInfo(receiverParameter.getValue(), true); + } + if (descriptorOfThisReceiver instanceof ClassDescriptor) { + return createInfo(((ClassDescriptor) descriptorOfThisReceiver).getThisAsReceiverParameter().getValue(), true); + } + return ERROR_IDENTIFIER_INFO; } public static boolean isStableVariable(@NotNull VariableDescriptor variableDescriptor) { diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt2422.kt b/compiler/testData/diagnostics/tests/smartCasts/kt2422.kt new file mode 100644 index 00000000000..ea3ac5e68fd --- /dev/null +++ b/compiler/testData/diagnostics/tests/smartCasts/kt2422.kt @@ -0,0 +1,23 @@ +package bar + +class Test { + val foo: Int? = null + fun foo(o: Test) = foo == null && o.foo == null // ERROR warning: o.test == null is always true + + fun bar(a: Test, b: Test) { + if (a.foo != null) { + useInt(b.foo) + } + if (a.foo != null) { + useInt(foo) + } + if (this.foo != null) { + useInt(foo) + } + if (foo != null) { + useInt(this.foo) + } + } + + fun useInt(i: Int) = i +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt b/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt new file mode 100644 index 00000000000..c993a144277 --- /dev/null +++ b/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt @@ -0,0 +1,25 @@ +//FILE: bar.kt +package bar + +val i: Int? = 2 + +//FILE: foo.kt +package foo + +val i: Int? = 1 + +class A(val i: Int?) { + fun testUseFromClass() { + if (foo.i != null) { + useInt(i) + } + } +} + +fun testUseFromOtherPackage() { + if (bar.i != null) { + useInt(i) + } +} + +fun useInt(i: Int) = i \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt b/compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt new file mode 100644 index 00000000000..618f5b66a69 --- /dev/null +++ b/compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt @@ -0,0 +1,36 @@ +package foo + +class A(val i: Int?) { + fun test1() { + if (this@A.i != null) { + useInt(this.i) + useInt(i) + } + } + + inner class B { + fun test2() { + if (i != null) { + useInt(this@A.i) + } + } + } +} + +fun A.foo() { + if (this@foo.i != null) { + useInt(this.i) + useInt(i) + } +} + +fun test3() { + useFunction { + if(i != null) { + useInt(this.i) + } + } +} + +fun useInt(i: Int) = i +fun useFunction(f: A.() -> Unit) = f \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt b/compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt new file mode 100644 index 00000000000..bdbc0aa44f7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt @@ -0,0 +1,39 @@ +package foo + +class C(val i: Int?) {} + +class A(val c: C) { + fun test1() { + if (this@A.c.i != null) { + useInt(this.c.i) + useInt(c.i) + } + } + + inner class B { + fun test2() { + if (c.i != null) { + useInt(this@A.c.i) + } + } + } +} + +fun A.foo() { + if (this@foo.c.i != null) { + useInt(this.c.i) + useInt(c.i) + } +} + +fun test3() { + useFunction { + if(c.i != null) { + useInt(this.c.i) + } + } +} + +fun useInt(i: Int) = i +fun useFunction(f: A.() -> Unit) = f + diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 115e37c96fa..3ccf049c0d8 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -4722,6 +4722,26 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/smartCasts/kt1461.kt"); } + @TestMetadata("kt2422.kt") + public void testKt2422() throws Exception { + doTest("compiler/testData/diagnostics/tests/smartCasts/kt2422.kt"); + } + + @TestMetadata("noErrorCheckForPackageLevelVal.kt") + public void testNoErrorCheckForPackageLevelVal() throws Exception { + doTest("compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt"); + } + + @TestMetadata("thisWithLabel.kt") + public void testThisWithLabel() throws Exception { + doTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt"); + } + + @TestMetadata("thisWithLabelAsReceiverPart.kt") + public void testThisWithLabelAsReceiverPart() throws Exception { + doTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt"); + } + } @TestMetadata("compiler/testData/diagnostics/tests/substitutions") From 42b34586bd47a2b0e81f061d585b4619ca3ef791 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 31 May 2013 14:10:58 +0400 Subject: [PATCH 81/92] made ReceiverValueVisitor an interface --- .../receivers/ReceiverValueVisitor.java | 26 +++++-------------- 1 file changed, 7 insertions(+), 19 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverValueVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverValueVisitor.java index 44281585f7c..110189c2330 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverValueVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverValueVisitor.java @@ -16,28 +16,16 @@ package org.jetbrains.jet.lang.resolve.scopes.receivers; -public class ReceiverValueVisitor { - public R visitNoReceiver(ReceiverValue noReceiver, D data) { - return null; - } +public interface ReceiverValueVisitor { + R visitNoReceiver(ReceiverValue noReceiver, D data); - public R visitTransientReceiver(TransientReceiver receiver, D data) { - return null; - } + R visitTransientReceiver(TransientReceiver receiver, D data); - public R visitExtensionReceiver(ExtensionReceiver receiver, D data) { - return null; - } + R visitExtensionReceiver(ExtensionReceiver receiver, D data); - public R visitExpressionReceiver(ExpressionReceiver receiver, D data) { - return null; - } + R visitExpressionReceiver(ExpressionReceiver receiver, D data); - public R visitClassReceiver(ClassReceiver receiver, D data) { - return null; - } + R visitClassReceiver(ClassReceiver receiver, D data); - public R visitScriptReceiver(ScriptReceiver receiver, D data) { - return null; - } + R visitScriptReceiver(ScriptReceiver receiver, D data); } From 61f50fc83247882574c5e3340fc8627c8ba340d3 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 31 May 2013 16:04:32 +0400 Subject: [PATCH 82/92] removed 'allowNamespaces' flag from creating IdentifierInfo --- .../calls/autocasts/DataFlowValueFactory.java | 24 +++++++++---------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index d8793b33b33..5399c1a0af1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -45,7 +45,7 @@ public class DataFlowValueFactory { if (constantExpression.getNode().getElementType() == JetNodeTypes.NULL) return DataFlowValue.NULL; } if (TypeUtils.equalTypes(type, KotlinBuiltIns.getInstance().getNullableNothingType())) return DataFlowValue.NULL; // 'null' is the only inhabitant of 'Nothing?' - IdentifierInfo result = getIdForStableIdentifier(expression, bindingContext, false); + IdentifierInfo result = getIdForStableIdentifier(expression, bindingContext); return new DataFlowValue(result.id == null ? expression : result.id, type, result.isStable, getImmanentNullability(type)); } @@ -127,8 +127,8 @@ public class DataFlowValueFactory { } @NotNull - private static IdentifierInfo createNamespaceInfo(Object id, boolean isStable) { - return new IdentifierInfo(id, isStable, true); + private static IdentifierInfo createNamespaceInfo(Object id) { + return new IdentifierInfo(id, true, true); } @NotNull @@ -142,26 +142,25 @@ public class DataFlowValueFactory { @NotNull private static IdentifierInfo getIdForStableIdentifier( @Nullable JetExpression expression, - @NotNull BindingContext bindingContext, - boolean allowNamespaces + @NotNull BindingContext bindingContext ) { if (expression instanceof JetParenthesizedExpression) { JetParenthesizedExpression parenthesizedExpression = (JetParenthesizedExpression) expression; JetExpression innerExpression = parenthesizedExpression.getExpression(); - return getIdForStableIdentifier(innerExpression, bindingContext, allowNamespaces); + return getIdForStableIdentifier(innerExpression, bindingContext); } else if (expression instanceof JetQualifiedExpression) { JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) expression; JetExpression receiverExpression = qualifiedExpression.getReceiverExpression(); JetExpression selectorExpression = qualifiedExpression.getSelectorExpression(); - IdentifierInfo receiverId = getIdForStableIdentifier(receiverExpression, bindingContext, true); - IdentifierInfo selectorId = getIdForStableIdentifier(selectorExpression, bindingContext, allowNamespaces); + IdentifierInfo receiverId = getIdForStableIdentifier(receiverExpression, bindingContext); + IdentifierInfo selectorId = getIdForStableIdentifier(selectorExpression, bindingContext); return combineInfo(receiverId, selectorId); } if (expression instanceof JetSimpleNameExpression) { - return getIdForSimpleNameExpression((JetSimpleNameExpression) expression, bindingContext, allowNamespaces); + return getIdForSimpleNameExpression((JetSimpleNameExpression) expression, bindingContext); } else if (expression instanceof JetThisExpression) { JetThisExpression thisExpression = (JetThisExpression) expression; @@ -170,7 +169,7 @@ public class DataFlowValueFactory { return getIdForThisReceiver(declarationDescriptor); } else if (expression instanceof JetRootNamespaceExpression) { - return createNamespaceInfo(JetModuleUtil.getRootNamespaceType(expression), allowNamespaces); + return createNamespaceInfo(JetModuleUtil.getRootNamespaceType(expression)); } return ERROR_IDENTIFIER_INFO; } @@ -178,8 +177,7 @@ public class DataFlowValueFactory { @NotNull private static IdentifierInfo getIdForSimpleNameExpression( @NotNull JetSimpleNameExpression simpleNameExpression, - @NotNull BindingContext bindingContext, - boolean allowNamespaces + @NotNull BindingContext bindingContext ) { DeclarationDescriptor declarationDescriptor = bindingContext.get(REFERENCE_TARGET, simpleNameExpression); if (declarationDescriptor instanceof VariableDescriptor) { @@ -194,7 +192,7 @@ public class DataFlowValueFactory { return combineInfo(receiverInfo, createInfo(variableDescriptor, isStableVariable(variableDescriptor))); } if (declarationDescriptor instanceof NamespaceDescriptor) { - return createNamespaceInfo(declarationDescriptor, allowNamespaces); + return createNamespaceInfo(declarationDescriptor); } if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; From 6d6e627641a9cc292c2023653ce58f29bf016c3d Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 31 May 2013 20:26:18 +0400 Subject: [PATCH 83/92] Support custom JDK annotations path for TeamCity --- .../jps/build/KotlinBuilderModuleScriptGenerator.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java index ce53354d6ad..593cf2407c6 100644 --- a/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java +++ b/jps-plugin/src/org/jetbrains/jet/jps/build/KotlinBuilderModuleScriptGenerator.java @@ -130,6 +130,16 @@ public class KotlinBuilderModuleScriptGenerator { } } + // JDK is stored locally on user's machine, so its configuration, including external annotation paths + // is not available on TeamCity. When running on TeamCity, one has to provide extra path to JDK annotations + String extraAnnotationsPaths = System.getProperty("jps.kotlin.extra.annotation.paths"); + if (extraAnnotationsPaths != null) { + String[] paths = extraAnnotationsPaths.split(File.pathSeparator); + for (String path : paths) { + annotationRootFiles.add(new File(path)); + } + } + return annotationRootFiles; } From 555e182d6dbf011c02b2966501e9036bee17c7d6 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 31 May 2013 20:42:39 +0400 Subject: [PATCH 84/92] Fix returned indices from TextBlockTransferableData Thanks to Alexander (https://github.com/Alefas) for idea #KT-3662 Fixed --- .../jetbrains/jet/plugin/conversion/copy/ConvertedCode.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/conversion/copy/ConvertedCode.java b/idea/src/org/jetbrains/jet/plugin/conversion/copy/ConvertedCode.java index 89827815faa..e9af4d9cebc 100644 --- a/idea/src/org/jetbrains/jet/plugin/conversion/copy/ConvertedCode.java +++ b/idea/src/org/jetbrains/jet/plugin/conversion/copy/ConvertedCode.java @@ -43,12 +43,12 @@ class ConvertedCode implements TextBlockTransferableData { @Override public int getOffsets(int[] offsets, int index) { - return 0; + return index; } @Override public int setOffsets(int[] offsets, int index) { - return 0; + return index; } public String getData() { From 6d0b8f953d847e9e0ab0ea905dd3aecb5c4b3d88 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 31 May 2013 15:36:15 +0400 Subject: [PATCH 85/92] Typo. --- compiler/preloader/instrumentation/ReadMe.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/preloader/instrumentation/ReadMe.md b/compiler/preloader/instrumentation/ReadMe.md index dfdb9eac23c..22506fd0086 100644 --- a/compiler/preloader/instrumentation/ReadMe.md +++ b/compiler/preloader/instrumentation/ReadMe.md @@ -27,7 +27,7 @@ This is determined by the ```src/META-INF/services/org.jetbrains.jet.preloading. Preloader loads the **first** instrumenter service found on the class path. Services are provided through the [standard JDK mechanism](http://docs.oracle.com/javase/6/docs/api/java/util/ServiceLoader.html). -Every preloaded class is run through the instrumenter. Before exiting the program instrumenter's dupm() method is called. +Every preloaded class is run through the instrumenter. Before exiting the program instrumenter's dump() method is called. **Note** JDK classes and everything in the Preloader's own class path are not preloaded, thus not instrumented. The ```instrumentation``` module provides a convenient way to define useful instrumenters: From 89b3f953d15716224728acf6cc8d1295129b42a9 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 31 May 2013 17:39:45 +0400 Subject: [PATCH 86/92] Fixed broken reference to jar. --- .idea/artifacts/instrumentation_jar.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.idea/artifacts/instrumentation_jar.xml b/.idea/artifacts/instrumentation_jar.xml index 5e0f98bc70e..be868324bfb 100644 --- a/.idea/artifacts/instrumentation_jar.xml +++ b/.idea/artifacts/instrumentation_jar.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file From 3e5feeb4361400b82c03923081a645c5276bcaaf Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 31 May 2013 17:39:57 +0400 Subject: [PATCH 87/92] Minor. Added comments. --- build.xml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/build.xml b/build.xml index 182b6655096..90421ff0b54 100644 --- a/build.xml +++ b/build.xml @@ -539,12 +539,15 @@ + + + From 343a28ac2d5b38e71bbd8666547b02b68d774573 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 3 Jun 2013 17:47:36 +0400 Subject: [PATCH 88/92] Ignored local Gradle repository. --- libraries/tools/kotlin-gradle-plugin/.gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100644 libraries/tools/kotlin-gradle-plugin/.gitignore diff --git a/libraries/tools/kotlin-gradle-plugin/.gitignore b/libraries/tools/kotlin-gradle-plugin/.gitignore new file mode 100644 index 00000000000..b97b22398a9 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/.gitignore @@ -0,0 +1 @@ +local-repo From c51a70b3b8af90ed863a61b32131bdd68943e9d5 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Mon, 3 Jun 2013 18:20:36 +0400 Subject: [PATCH 89/92] Optimized obtaining super methods. --- .../PropagationHeuristics.java | 119 +++++++++++++++++- 1 file changed, 115 insertions(+), 4 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java index abe2a333b0d..941175e951c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java @@ -17,9 +17,11 @@ package org.jetbrains.jet.lang.resolve.java.kotlinSignature; import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Condition; -import com.intellij.psi.HierarchicalMethodSignature; -import com.intellij.psi.PsiMethod; +import com.intellij.psi.*; +import com.intellij.psi.impl.PsiSubstitutorImpl; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -38,7 +40,11 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.renderer.DescriptorRenderer; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.Map; + +import static com.intellij.psi.util.TypeConversionUtil.erasure; // This class contains heuristics for processing corner cases in propagation class PropagationHeuristics { @@ -122,8 +128,7 @@ class PropagationHeuristics { @NotNull static List getSuperMethods(@NotNull PsiMethod method) { List superMethods = Lists.newArrayList(); - for (HierarchicalMethodSignature superSignature : method.getHierarchicalMethodSignature().getSuperSignatures()) { - PsiMethod superMethod = superSignature.getMethod(); + for (PsiMethod superMethod : new SuperMethodCollector(method).collect()) { CallableMemberDescriptor.Kind kindFromFlags = DescriptorKindUtils.flagsToKind(new PsiMethodWrapper(superMethod).getJetMethodAnnotation().kind()); if (kindFromFlags == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { @@ -141,4 +146,110 @@ class PropagationHeuristics { private PropagationHeuristics() { } + + private static class SuperMethodCollector { + private final PsiMethod initialMethod; + private final String initialMethodName; + private final List initialParametersErasure; + + private final List visitedSuperclasses = Lists.newArrayList(); + private final List collectedMethods = Lists.newArrayList(); + + private SuperMethodCollector(@NotNull PsiMethod initialMethod) { + this.initialMethod = initialMethod; + initialMethodName = initialMethod.getName(); + + PsiParameterList parameterList = initialMethod.getParameterList(); + initialParametersErasure = Lists.newArrayListWithExpectedSize(parameterList.getParametersCount()); + for (PsiParameter parameter : parameterList.getParameters()) { + initialParametersErasure.add(erasureNoEllipsis(parameter.getType())); + } + } + + public List collect() { + if (!canHaveSuperMethod(initialMethod)) { + return Collections.emptyList(); + } + + PsiClass containingClass = initialMethod.getContainingClass(); + assert containingClass != null : " containing class is null for " + initialMethod; + + for (PsiClassType superType : containingClass.getSuperTypes()) { + collectFromSupertype(superType); + } + + return collectedMethods; + } + + private void collectFromSupertype(PsiClassType type) { + PsiClass klass = type.resolve(); + if (klass == null) { + return; + } + if (!visitedSuperclasses.add(klass)) { + return; + } + + PsiSubstitutor supertypeSubstitutor = getErasedSubstitutor(type); + for (PsiMethod methodFromSuper : klass.getMethods()) { + if (isSubMethodOf(methodFromSuper, supertypeSubstitutor)) { + collectedMethods.add(methodFromSuper); + return; + } + } + + for (PsiType superType : type.getSuperTypes()) { + assert superType instanceof PsiClassType : "supertype is not a PsiClassType for " + type + ": " + superType; + collectFromSupertype((PsiClassType) superType); + } + } + + private boolean isSubMethodOf(@NotNull PsiMethod methodFromSuper, @NotNull PsiSubstitutor supertypeSubstitutor) { + if (!methodFromSuper.getName().equals(initialMethodName)) { + return false; + } + + PsiParameterList fromSuperParameterList = methodFromSuper.getParameterList(); + + if (fromSuperParameterList.getParametersCount() != initialParametersErasure.size()) { + return false; + } + + for (int i = 0; i < initialParametersErasure.size(); i++) { + PsiType originalType = initialParametersErasure.get(i); + PsiType typeFromSuper = fromSuperParameterList.getParameters()[i].getType(); + PsiType typeFromSuperErased = erasureNoEllipsis(supertypeSubstitutor.substitute(typeFromSuper)); + + if (!Comparing.equal(originalType, typeFromSuperErased)) { + return false; + } + } + + return true; + } + + private static PsiType erasureNoEllipsis(PsiType type) { + if (type instanceof PsiEllipsisType) { + return erasureNoEllipsis(((PsiEllipsisType) type).toArrayType()); + } + return erasure(type); + } + + private static PsiSubstitutor getErasedSubstitutor(PsiClassType type) { + Map unerasedMap = type.resolveGenerics().getSubstitutor().getSubstitutionMap(); + Map erasedMap = Maps.newHashMapWithExpectedSize(unerasedMap.size()); + for (Map.Entry entry : unerasedMap.entrySet()) { + erasedMap.put(entry.getKey(), erasure(entry.getValue())); + } + return PsiSubstitutorImpl.createSubstitutor(erasedMap); + } + + private static boolean canHaveSuperMethod(PsiMethod method) { + if (method.isConstructor()) return false; + if (method.hasModifierProperty(PsiModifier.STATIC)) return false; + if (method.hasModifierProperty(PsiModifier.PRIVATE)) return false; + PsiClass containingClass = method.getContainingClass(); + return containingClass != null && !CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName()); + } + } } From 9270eec30ff6f7001f1b88f66fbabbde8c8441f0 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 15:30:02 +0400 Subject: [PATCH 90/92] Using properties for dependency build id's (cherry picked from commit 68b0aa0) --- update_dependencies.xml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index b3fe11a630b..1d2c8f09340 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,16 +1,19 @@ + + + From ce402068c9228c84ce9cd6dead42172f8369256a Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 15:47:59 +0400 Subject: [PATCH 91/92] Using a property for IDEA zip name (cherry picked from commit 42683dc) --- update_dependencies.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 1d2c8f09340..993c64ab546 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,20 +1,21 @@ + From acbccb9411194c6fd3fa8c20831084ec1dbaf716 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Mon, 3 Jun 2013 13:58:53 +0400 Subject: [PATCH 92/92] Get asm from fixed idea build (jar with debug info and patched for java 8) --- update_dependencies.xml | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 993c64ab546..8af22a17daf 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -126,17 +126,9 @@ - - - - - - - - - - - + + +