From 530dc1ca95d240bdddf7081cf22ee4b0c6b3d425 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 20 May 2013 12:23:39 +0400 Subject: [PATCH 01/66] ~ Trying to run with IDEA 13 EAP (130.555) --- .../jet/plugin/project/K2JSModuleComponent.java | 7 ++----- .../jet/plugin/quickfix/ExclExclCallFix.java | 4 ++-- .../jet/plugin/quickfix/JetIntentionAction.java | 7 ++----- .../plugin/quickfix/MapPlatformClassToKotlinFix.java | 2 +- update_dependencies.xml | 12 ++++++------ 5 files changed, 13 insertions(+), 19 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/project/K2JSModuleComponent.java b/idea/src/org/jetbrains/jet/plugin/project/K2JSModuleComponent.java index c25cbe3fac1..90d4caf28c1 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/K2JSModuleComponent.java +++ b/idea/src/org/jetbrains/jet/plugin/project/K2JSModuleComponent.java @@ -21,17 +21,14 @@ import com.intellij.openapi.components.State; import com.intellij.openapi.components.Storage; import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleComponent; -import com.intellij.openapi.roots.impl.storage.ClasspathStorage; -import com.intellij.util.xmlb.XmlSerializerUtil; +import com.intellij.openapi.roots.impl.storage.ClassPathStorageUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.k2js.config.EcmaVersion; @Deprecated @State( name = "K2JSModule", storages = @Storage( - id = ClasspathStorage.DEFAULT_STORAGE, + id = ClassPathStorageUtil.DEFAULT_STORAGE, file = "$MODULE_FILE$" ) ) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java index efb955cff18..8db90f07d04 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ExclExclCallFix.java @@ -16,7 +16,7 @@ package org.jetbrains.jet.plugin.quickfix; -import com.intellij.codeInsight.CodeInsightUtilBase; +import com.intellij.codeInsight.FileModificationService; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; @@ -79,7 +79,7 @@ public class ExclExclCallFix implements IntentionAction { @Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { - if (!CodeInsightUtilBase.prepareFileForWrite(file)) { + if (!FileModificationService.getInstance().prepareFileForWrite(file)) { return; } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java index d05abb298e2..9e0c4d4210a 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java @@ -16,17 +16,14 @@ package org.jetbrains.jet.plugin.quickfix; -import com.intellij.codeInsight.CodeInsightUtilBase; +import com.intellij.codeInsight.FileModificationService; 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.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.JetFile; public abstract class JetIntentionAction implements IntentionAction { @@ -46,7 +43,7 @@ public abstract class JetIntentionAction implements Intent @Override public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException { if (file instanceof JetFile) { - if (CodeInsightUtilBase.prepareFileForWrite(element.getContainingFile())) { + if (FileModificationService.getInstance().prepareFileForWrite(element.getContainingFile())) { invoke(project, editor, (JetFile) file); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java index 7ff095f5768..414018fb505 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java @@ -150,7 +150,7 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction @@ -114,7 +114,7 @@ --> - + @@ -190,7 +190,7 @@ - + From 68b0aa0eb2646cfc3020d3de55bff33571182adc Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 15:30:02 +0400 Subject: [PATCH 02/66] Using properties for dependency build id's --- update_dependencies.xml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 0a24d39d144..d59758858d0 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,16 +1,19 @@ + + + From 42683dce6953c07d395f7cdec26ea65514d915c5 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 15:47:59 +0400 Subject: [PATCH 03/66] Using a property for IDEA zip name --- update_dependencies.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index d59758858d0..f13e0ae05ea 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,20 +1,21 @@ + From fea302c817112ee3bf6b67d074f639acc93c9dfc Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 28 May 2013 12:08:01 +0400 Subject: [PATCH 04/66] Trying IDEA 130.703 --- update_dependencies.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index f13e0ae05ea..33aa5d11974 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,6 +1,6 @@ - + From 87739107f81520654f1074a396c748c32ab7cb78 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 28 May 2013 14:11:03 +0400 Subject: [PATCH 05/66] Using protobuf 2.5.0 --- update_dependencies.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 33aa5d11974..7d49fd202ce 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -208,7 +208,7 @@ - + From bf6cd41d82b35d7c35204ea7852b8f4aff6b98c0 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 28 May 2013 14:33:02 +0400 Subject: [PATCH 06/66] IDEA 130.703 for internal build server --- update_dependencies.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 7d49fd202ce..531068ea13f 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,5 +1,5 @@ - + From 386a881a7191209c8096fa8ff0ef646dac2d78da Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Wed, 29 May 2013 15:30:03 +0400 Subject: [PATCH 07/66] Add new annotations --- jdk-annotations/java/io/annotations.xml | 3 +++ jdk-annotations/java/lang/annotations.xml | 3 +++ jdk-annotations/java/net/annotations.xml | 6 ++++++ jdk-annotations/java/nio/annotations.xml | 6 ++++++ jdk-annotations/java/util/annotations.xml | 3 +++ 5 files changed, 21 insertions(+) diff --git a/jdk-annotations/java/io/annotations.xml b/jdk-annotations/java/io/annotations.xml index 665f4d87c05..4c510479b92 100644 --- a/jdk-annotations/java/io/annotations.xml +++ b/jdk-annotations/java/io/annotations.xml @@ -906,6 +906,9 @@ + + + diff --git a/jdk-annotations/java/lang/annotations.xml b/jdk-annotations/java/lang/annotations.xml index dc404c0ddaf..d8f6eb8a2d0 100644 --- a/jdk-annotations/java/lang/annotations.xml +++ b/jdk-annotations/java/lang/annotations.xml @@ -1187,6 +1187,9 @@ + + + diff --git a/jdk-annotations/java/net/annotations.xml b/jdk-annotations/java/net/annotations.xml index e50303fd43a..290782ce0d0 100644 --- a/jdk-annotations/java/net/annotations.xml +++ b/jdk-annotations/java/net/annotations.xml @@ -318,6 +318,9 @@ + + + @@ -333,6 +336,9 @@ + + + diff --git a/jdk-annotations/java/nio/annotations.xml b/jdk-annotations/java/nio/annotations.xml index b5297ebbfa5..a299a37bb9f 100644 --- a/jdk-annotations/java/nio/annotations.xml +++ b/jdk-annotations/java/nio/annotations.xml @@ -21,6 +21,9 @@ + + + @@ -60,6 +63,9 @@ + + + diff --git a/jdk-annotations/java/util/annotations.xml b/jdk-annotations/java/util/annotations.xml index 1138f99e005..e7d04fb603d 100644 --- a/jdk-annotations/java/util/annotations.xml +++ b/jdk-annotations/java/util/annotations.xml @@ -2131,6 +2131,9 @@ + + + From c37a3713d3b5f2318dc111f190e163960280309c Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Tue, 28 May 2013 17:27:55 +0400 Subject: [PATCH 08/66] Fix tests for j2converter --- j2k/src/org/jetbrains/jet/j2k/Converter.java | 9 ++++++ j2k/tests/j2k-tests.iml | 1 + .../StandaloneJavaToKotlinConverterTest.java | 32 ++++--------------- 3 files changed, 17 insertions(+), 25 deletions(-) diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.java b/j2k/src/org/jetbrains/jet/j2k/Converter.java index 9cefa372f01..f4abee3d06a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.java +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.java @@ -46,6 +46,9 @@ public class Converter { "javax.annotation.Nonnull" ); + @NotNull + private final Project project; + @NotNull private Set classIdentifiers = Sets.newHashSet(); @@ -59,9 +62,15 @@ public class Converter { private final Set flags = Sets.newHashSet(); public Converter(@NotNull Project project) { + this.project = project; KotlinBuiltIns.initialize(project, KotlinBuiltIns.InitializationMode.MULTI_THREADED); } + @NotNull + public Project getProject() { + return project; + } + public boolean addFlag(@NotNull J2KConverterFlags flag) { return flags.add(flag); } diff --git a/j2k/tests/j2k-tests.iml b/j2k/tests/j2k-tests.iml index 0d3d4fd6bce..bd44f2f04ce 100644 --- a/j2k/tests/j2k-tests.iml +++ b/j2k/tests/j2k-tests.iml @@ -13,6 +13,7 @@ + diff --git a/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java b/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java index b5a97417e62..de1f996a202 100644 --- a/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java +++ b/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java @@ -16,44 +16,24 @@ package org.jetbrains.jet.j2k; -import com.intellij.openapi.Disposable; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiJavaFile; +import com.intellij.testFramework.UsefulTestCase; import junit.framework.Assert; import junit.framework.Test; -import junit.framework.TestCase; import junit.framework.TestSuite; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; +import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.config.CompilerConfiguration; -import org.jetbrains.jet.utils.PathUtil; import java.io.File; import java.io.IOException; -public class StandaloneJavaToKotlinConverterTest extends TestCase { - private static final JetCoreEnvironment jetCoreEnvironment; - - static { - CompilerConfiguration config = new CompilerConfiguration(); - - config.add(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.findRtJar()); - File annotations = JavaToKotlinTranslator.findAnnotations(); - if (annotations != null && annotations.exists()) { - config.add(JVMConfigurationKeys.CLASSPATH_KEY, annotations); - } - - Disposable disposable = new Disposable() { - @Override - public void dispose() { - } - }; - jetCoreEnvironment = new JetCoreEnvironment(disposable, config); - } +import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations; +public class StandaloneJavaToKotlinConverterTest extends UsefulTestCase { private final String myDataPath; private final String myName; @@ -64,7 +44,9 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { @Override protected void runTest() throws Throwable { + JetCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable(), ConfigurationKind.JDK_ONLY); Converter converter = new Converter(jetCoreEnvironment.getProject()); + String javaPath = "j2k/tests/testData/" + getTestFilePath(); String kotlinPath = javaPath.replace(".jav", ".kt"); @@ -140,7 +122,7 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { @NotNull private String fileToKotlin(Converter converter, @NotNull String text) { - return generateKotlinCode(converter, JavaToKotlinTranslator.createFile(jetCoreEnvironment.getProject(), text)); + return generateKotlinCode(converter, JavaToKotlinTranslator.createFile(converter.getProject(), text)); } @NotNull From cc96f397ebc4a6ce1ad36542923c9a2df1925425 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Wed, 29 May 2013 11:38:55 +0400 Subject: [PATCH 09/66] Update idea versions in plugin.xml --- idea/src/META-INF/plugin.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index a942b5d6e55..01c9c9d4e01 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -6,7 +6,7 @@ @snapshot@ JetBrains Inc. - + JUnit com.intellij.copyright From 7243ef462793a0d10c4fca0207b18e1b2fc2d03e Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 13 May 2013 16:21:19 +0400 Subject: [PATCH 10/66] 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 f454a40eacac138ccd966ba06988f1faab8f25dc Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 26 Apr 2013 18:37:20 +0400 Subject: [PATCH 11/66] 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 0779f1bbde089e1f75e3e6de59fa3b744ce7012e Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 8 May 2013 12:31:00 +0400 Subject: [PATCH 12/66] 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 7b8f0779ad77e85ce0dc5cacc8b4129008f16592 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 19:08:06 +0400 Subject: [PATCH 13/66] 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 bdb7e5b945b9214e2deb4d878a1a90e752e2b178 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 19:07:53 +0400 Subject: [PATCH 14/66] 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 b4cfe605ec7469232272849293155a3ade636258 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Fri, 26 Apr 2013 18:38:43 +0400 Subject: [PATCH 15/66] 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 85e5ce81110314acec3d9b97e5482159be363083 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 14 May 2013 01:09:51 +0400 Subject: [PATCH 16/66] 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 1f8fad9ec0a8080aa167c62008aaff2525b59a44 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 8 May 2013 18:15:55 +0400 Subject: [PATCH 17/66] 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 01c9c9d4e01..f1339a65932 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 fbe3af3fdfe7559267dcf32af3f1229ef483c0cf Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 6 May 2013 15:58:14 +0400 Subject: [PATCH 18/66] 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 bed43db274a8dc5e1950a897bae0709d9dd4476e Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Tue, 14 May 2013 17:12:58 +0400 Subject: [PATCH 19/66] 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 461e83a5d1dd46a1b51abe491f4d04a4c99f7396 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 16 May 2013 18:44:58 +0400 Subject: [PATCH 20/66] 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 21/66] 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 22/66] 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 e0d1190d5e7335a876630bf5f854c25b4984ae6f Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 16:03:03 +0400 Subject: [PATCH 23/66] 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 bbc49ca9fcfb60f76602bd10664c12abea5046c8 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Mon, 20 May 2013 16:28:04 +0400 Subject: [PATCH 24/66] 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 dc3d3952146bee4082b48ec87f5fd6e57a0534c9 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 14:03:17 +0400 Subject: [PATCH 25/66] 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 ef819cce5a4bb5d8cc578eeff28301874a54f4b0 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 15 May 2013 15:27:09 +0400 Subject: [PATCH 26/66] 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 0bfa5cd95404262cd23f52ca678f75236f2cf543 Mon Sep 17 00:00:00 2001 From: chocolateboy Date: Wed, 8 May 2013 05:10:19 +0100 Subject: [PATCH 27/66] 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 0ab434ac2d6c1846e00571ab2c391e79b01967b1 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Mon, 20 May 2013 12:13:42 +0400 Subject: [PATCH 28/66] 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 485923b19719e5f793853540a27b57365a5f49af Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Mon, 20 May 2013 13:10:35 +0400 Subject: [PATCH 29/66] 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 fad29b8ad1e24a18677179d6e2224d7bbc47f560 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 21 May 2013 13:01:31 +0400 Subject: [PATCH 30/66] 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 531068ea13f..7ec9ad1fb71 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -127,28 +127,20 @@ - - - + - - - - - - - - + + - + @@ -198,7 +190,7 @@ - + @@ -231,7 +223,8 @@ - + + @@ -243,6 +236,12 @@ --> + + + From e05a9efeab04ad205ba23884a8a761386267c681 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Tue, 21 May 2013 14:20:41 +0400 Subject: [PATCH 31/66] 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 32/66] 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 08f902d373d8866c5252f491356833bc9089e8c3 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 8 May 2013 16:12:13 +0400 Subject: [PATCH 33/66] 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 3c770c264666f6f23264778b96a4fbe7c276c5b5 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 17 May 2013 19:14:36 +0400 Subject: [PATCH 34/66] 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 6c12b694af3c143df14c5c3b45d1feca2e5775d4 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 17 May 2013 20:54:36 +0400 Subject: [PATCH 35/66] 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 f6a6b55ffa93947faa9c9a6d690f02fcf18f410a Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 13:14:28 +0400 Subject: [PATCH 36/66] 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 cdb096035be1a7be251be04a50afefdad6decab6 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 14:19:56 +0400 Subject: [PATCH 37/66] 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 19e1331c112d1474cd005a809e4d32eb8abbf794 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 16:37:24 +0400 Subject: [PATCH 38/66] 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 f52338a5829b2b14f3070ba058acfde4a465474a Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 21 May 2013 17:56:04 +0400 Subject: [PATCH 39/66] 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 ff47c4b5853125334f0a229377b9d3bc12b22b78 Mon Sep 17 00:00:00 2001 From: Martin Lau Date: Wed, 22 May 2013 12:05:05 +1000 Subject: [PATCH 40/66] 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 8694cfa9adc79b8bf221313c8068a7bc58a21413 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 22 May 2013 20:52:09 +0400 Subject: [PATCH 41/66] 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 8511137596aabfca2affccd6588e169c0b6a5523 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 22 May 2013 20:31:26 +0400 Subject: [PATCH 42/66] 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 aa90dac6d1909dca0877abf4ec7dad4ed350b67f Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 27 May 2013 13:55:05 +0400 Subject: [PATCH 43/66] 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 11c44890a70334e091960ab14b48e854b395cab2 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Mon, 27 May 2013 14:38:05 +0400 Subject: [PATCH 44/66] 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 642d073bc98222d0433eea40f2fe565648233514 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 45/66] 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 d8492587579aff0b7e57d78fe65131e42b426f2e 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 46/66] 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 92659ca7a5f0e67a123b628dc6f46c3642de591d Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Wed, 22 May 2013 19:23:59 +0400 Subject: [PATCH 47/66] 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 c4bdf7205412d471cd52db8fd19923c501262ec5 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Thu, 23 May 2013 18:32:13 +0400 Subject: [PATCH 48/66] 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 9dfe0f42a38c2f482166b2744b9dc270d9ce3e17 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Fri, 24 May 2013 13:42:15 +0400 Subject: [PATCH 49/66] 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 85ab1619a7d3cb83e613e5441d434cf08922c873 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 12:23:18 +0400 Subject: [PATCH 50/66] 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 940008cdaa0bf3e9885c9bc06b248b078ffbf486 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 15:22:52 +0400 Subject: [PATCH 51/66] 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 d847123c9c9c930e2d803d52cc919f10fddc3508 Mon Sep 17 00:00:00 2001 From: Sergey Rostov Date: Sat, 25 May 2013 19:05:01 +0400 Subject: [PATCH 52/66] 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 61b495e95c773bedbed9e10e48fe8480d2cd0671 Mon Sep 17 00:00:00 2001 From: Mikhael Bogdanov Date: Tue, 28 May 2013 15:55:57 +0400 Subject: [PATCH 53/66] 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 771cf85179addaf1bfa985922c127005fa220bfd Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:07 +0400 Subject: [PATCH 54/66] 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 b2ed1b1e965f5d3ddc5c33df46a79915b93daca0 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:32 +0400 Subject: [PATCH 55/66] 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 63899bdd5d703d9338eca07462951a21204d1762 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 19:47:45 +0400 Subject: [PATCH 56/66] 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 bc8a6d9023af57b01c6448b50c7c32df8ebc3721 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 28 May 2013 20:06:39 +0400 Subject: [PATCH 57/66] 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 a8267b370e9eb0935025fd8e1b9981ac15efd9db Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 29 May 2013 21:07:54 +0400 Subject: [PATCH 58/66] 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 5a50caa8ac65087586e3cdf49e9153c467bd8da1 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 29 May 2013 21:28:26 +0400 Subject: [PATCH 59/66] 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 92bc46ab8f3feab6105378d6b0aa2c61c4c8082b Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 30 May 2013 12:53:26 +0400 Subject: [PATCH 60/66] 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 fc3a413fbaaa12e28760474e69dd4be927d1fdd8 Mon Sep 17 00:00:00 2001 From: "Natalia.Ukhorskaya" Date: Wed, 29 May 2013 15:30:03 +0400 Subject: [PATCH 61/66] 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 d9d8598b56b6590aea58505ad7285029b38a5fc6 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 6 Jun 2013 19:18:47 +0400 Subject: [PATCH 62/66] Subclassed from PsiClassHolderFileStub. --- .../psi/stubs/impl/PsiJetFileStubImpl.java | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/PsiJetFileStubImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/PsiJetFileStubImpl.java index fc04bea18a1..c46c0e1d84a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/PsiJetFileStubImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/PsiJetFileStubImpl.java @@ -16,14 +16,21 @@ package org.jetbrains.jet.lang.psi.stubs.impl; +import com.google.common.collect.Lists; +import com.intellij.psi.PsiClass; +import com.intellij.psi.impl.java.stubs.PsiClassStub; +import com.intellij.psi.stubs.PsiClassHolderFileStub; import com.intellij.psi.stubs.PsiFileStubImpl; +import com.intellij.psi.stubs.StubElement; import com.intellij.psi.tree.IStubFileElementType; import com.intellij.util.io.StringRef; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.stubs.PsiJetFileStub; import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes; -public class PsiJetFileStubImpl extends PsiFileStubImpl implements PsiJetFileStub { +import java.util.List; + +public class PsiJetFileStubImpl extends PsiFileStubImpl implements PsiJetFileStub, PsiClassHolderFileStub { private final StringRef packageName; private final boolean isScript; @@ -65,4 +72,15 @@ public class PsiJetFileStubImpl extends PsiFileStubImpl implements PsiJ return builder.toString(); } + + @Override + public PsiClass[] getClasses() { + List result = Lists.newArrayList(); + for (StubElement child : getChildrenStubs()) { + if (child instanceof PsiClassStub) { + result.add((PsiClass) child.getPsi()); + } + } + return result.toArray(new PsiClass[result.size()]); + } } From ec4aa352bb68cda8e58977336a57159dc1c016be Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 6 Jun 2013 21:19:02 +0400 Subject: [PATCH 63/66] Not loading SAM adapters from compiled Kotlin classes. --- .../resolve/java/resolver/JavaFunctionResolver.java | 4 +++- compiler/testData/loadKotlin/fun/NoSamAdapter.txt | 7 +++++++ compiler/testData/loadKotlin/fun/NoSamConstructor.txt | 5 +++++ compiler/testData/loadKotlin/fun/noSamAdapter.kt | 8 ++++++++ compiler/testData/loadKotlin/fun/noSamConstructor.kt | 5 +++++ .../jvm/compiler/LoadCompiledKotlinTestGenerated.java | 10 ++++++++++ .../LazyResolveNamespaceComparingTestGenerated.java | 10 ++++++++++ 7 files changed, 48 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/loadKotlin/fun/NoSamAdapter.txt create mode 100644 compiler/testData/loadKotlin/fun/NoSamConstructor.txt create mode 100644 compiler/testData/loadKotlin/fun/noSamAdapter.kt create mode 100644 compiler/testData/loadKotlin/fun/noSamConstructor.kt 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 b85f90e7b20..8372ed45dc2 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 @@ -280,7 +280,9 @@ public final class JavaFunctionResolver { if (function != null) { functionsFromCurrent.add(function); - ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function)); + if (!DescriptorResolverUtils.isKotlinClass(psiClass)) { + ContainerUtil.addIfNotNull(functionsFromCurrent, resolveSamAdapter(function)); + } } } diff --git a/compiler/testData/loadKotlin/fun/NoSamAdapter.txt b/compiler/testData/loadKotlin/fun/NoSamAdapter.txt new file mode 100644 index 00000000000..311635dec88 --- /dev/null +++ b/compiler/testData/loadKotlin/fun/NoSamAdapter.txt @@ -0,0 +1,7 @@ +package test + +internal fun foo(/*0*/ r: java.lang.Runnable): jet.Unit + +public trait TaskObject { + internal abstract fun foo(/*0*/ r: java.lang.Runnable): jet.Unit +} diff --git a/compiler/testData/loadKotlin/fun/NoSamConstructor.txt b/compiler/testData/loadKotlin/fun/NoSamConstructor.txt new file mode 100644 index 00000000000..8afb2805767 --- /dev/null +++ b/compiler/testData/loadKotlin/fun/NoSamConstructor.txt @@ -0,0 +1,5 @@ +package test + +public trait Runnable { + internal abstract fun run(): jet.Unit +} diff --git a/compiler/testData/loadKotlin/fun/noSamAdapter.kt b/compiler/testData/loadKotlin/fun/noSamAdapter.kt new file mode 100644 index 00000000000..56722ba6d48 --- /dev/null +++ b/compiler/testData/loadKotlin/fun/noSamAdapter.kt @@ -0,0 +1,8 @@ +package test + +public trait TaskObject { + fun foo(r: Runnable) +} + +fun foo(r: Runnable) { +} \ No newline at end of file diff --git a/compiler/testData/loadKotlin/fun/noSamConstructor.kt b/compiler/testData/loadKotlin/fun/noSamConstructor.kt new file mode 100644 index 00000000000..91cd7ae7e6d --- /dev/null +++ b/compiler/testData/loadKotlin/fun/noSamConstructor.kt @@ -0,0 +1,5 @@ +package test + +public trait Runnable { + fun run() +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java index 89e993dc3e8..595eeab747e 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java @@ -414,6 +414,16 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("NoSamAdapter.kt") + public void testNoSamAdapter() throws Exception { + doTestWithAccessors("compiler/testData/loadKotlin/fun/NoSamAdapter.kt"); + } + + @TestMetadata("NoSamConstructor.kt") + public void testNoSamConstructor() throws Exception { + doTestWithAccessors("compiler/testData/loadKotlin/fun/NoSamConstructor.kt"); + } + @TestMetadata("PropagateDeepSubclass.kt") public void testPropagateDeepSubclass() throws Exception { doTestWithAccessors("compiler/testData/loadKotlin/fun/PropagateDeepSubclass.kt"); 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 b2bcdbb32bf..e26cdf37436 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -416,6 +416,16 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("NoSamAdapter.kt") + public void testNoSamAdapter() throws Exception { + doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/NoSamAdapter.kt"); + } + + @TestMetadata("NoSamConstructor.kt") + public void testNoSamConstructor() throws Exception { + doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/NoSamConstructor.kt"); + } + @TestMetadata("PropagateDeepSubclass.kt") public void testPropagateDeepSubclass() throws Exception { doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/PropagateDeepSubclass.kt"); From 9c29c8231598ceaa873efe7831fa591ea85849ce Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Thu, 6 Jun 2013 21:57:35 +0400 Subject: [PATCH 64/66] Fixed filename case. --- .../testData/loadKotlin/fun/{noSamAdapter.kt => NoSamAdapter.kt} | 0 .../loadKotlin/fun/{noSamConstructor.kt => NoSamConstructor.kt} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename compiler/testData/loadKotlin/fun/{noSamAdapter.kt => NoSamAdapter.kt} (100%) rename compiler/testData/loadKotlin/fun/{noSamConstructor.kt => NoSamConstructor.kt} (100%) diff --git a/compiler/testData/loadKotlin/fun/noSamAdapter.kt b/compiler/testData/loadKotlin/fun/NoSamAdapter.kt similarity index 100% rename from compiler/testData/loadKotlin/fun/noSamAdapter.kt rename to compiler/testData/loadKotlin/fun/NoSamAdapter.kt diff --git a/compiler/testData/loadKotlin/fun/noSamConstructor.kt b/compiler/testData/loadKotlin/fun/NoSamConstructor.kt similarity index 100% rename from compiler/testData/loadKotlin/fun/noSamConstructor.kt rename to compiler/testData/loadKotlin/fun/NoSamConstructor.kt From 1565a2da3c577557d2d5d5c89719c12e2f04dea5 Mon Sep 17 00:00:00 2001 From: Erokhin Stanislav Date: Tue, 9 Jul 2013 19:54:43 +0400 Subject: [PATCH 65/66] Update to IDEA 130.703 --- update_dependencies.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/update_dependencies.xml b/update_dependencies.xml index 234d504126e..7ba18984b64 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,5 +1,5 @@ - + From 33efbc3e9138b818a5044a6d5faa033376efdd43 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 23 Jul 2013 17:34:33 +0400 Subject: [PATCH 66/66] Migrate to IDEA 130.1225 Fix the class loader to generate proper resource URLs: we used to have "!" as a JAR separator, but the correct one is "!/", according to the docs here: http://docs.oracle.com/javase/6/docs/api/java/net/JarURLConnection.html --- .../org/jetbrains/jet/preloading/ClassPreloadingUtils.java | 2 +- update_dependencies.xml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/preloader/src/org/jetbrains/jet/preloading/ClassPreloadingUtils.java b/compiler/preloader/src/org/jetbrains/jet/preloading/ClassPreloadingUtils.java index a9cf32480a8..3f129f6d813 100644 --- a/compiler/preloader/src/org/jetbrains/jet/preloading/ClassPreloadingUtils.java +++ b/compiler/preloader/src/org/jetbrains/jet/preloading/ClassPreloadingUtils.java @@ -191,7 +191,7 @@ public class ClassPreloadingUtils { public URL getURL() { try { - String path = "file:" + jarFile + "!" + resourceName; + String path = "file:" + jarFile + "!/" + resourceName; return new URL("jar", null, 0, path, new URLStreamHandler() { @Override protected URLConnection openConnection(URL u) throws IOException { diff --git a/update_dependencies.xml b/update_dependencies.xml index 7ba18984b64..5fdf093cf5c 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,6 +1,6 @@ - - + +