From 055cad793c5855681e945e982a3afa2bc72fb8e2 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Fri, 1 Jun 2012 17:03:06 +0200 Subject: [PATCH] ConverterUtil to namespace-level functions in Converter.kt --- src/org/jetbrains/jet/j2k/Converter.kt | 127 ++++++++++++++++- src/org/jetbrains/jet/j2k/ConverterUtil.java | 132 ------------------ .../jet/j2k/visitors/ElementVisitor.kt | 2 +- .../jet/j2k/visitors/StatementVisitor.kt | 2 +- 4 files changed, 123 insertions(+), 140 deletions(-) delete mode 100644 src/org/jetbrains/jet/j2k/ConverterUtil.java diff --git a/src/org/jetbrains/jet/j2k/Converter.kt b/src/org/jetbrains/jet/j2k/Converter.kt index c2da7368b30..579c673d99b 100644 --- a/src/org/jetbrains/jet/j2k/Converter.kt +++ b/src/org/jetbrains/jet/j2k/Converter.kt @@ -14,10 +14,11 @@ import org.jetbrains.jet.j2k.ast.types.Type import org.jetbrains.jet.j2k.visitors.* import org.jetbrains.jet.lang.types.expressions.OperatorConventions import java.util.* -import org.jetbrains.jet.j2k.ConverterUtil.countWritingAccesses -import org.jetbrains.jet.j2k.ConverterUtil.createMainFunction import com.intellij.psi.CommonClassNames.* import org.jetbrains.jet.lang.types.expressions.OperatorConventions.* +import com.intellij.openapi.util.Pair +import java.text.MessageFormat +import com.intellij.psi.util.PsiUtil public open class Converter() { private var classIdentifiers: Set = hashSet() @@ -244,7 +245,7 @@ public open class Converter() { } methodReturnType = method.getReturnType() val identifier: Identifier = Identifier(method.getName()) - val returnType: Type = typeToType(method.getReturnType(), ConverterUtil.isAnnotatedAsNotNull(method.getModifierList())) + val returnType: Type = typeToType(method.getReturnType(), isAnnotatedAsNotNull(method.getModifierList())) val body: Block = (if (hasFlag(J2KConverterFlags.SKIP_BODIES)) Block.EMPTY_BLOCK else @@ -281,8 +282,8 @@ public open class Converter() { for (parameter : PsiParameter? in method.getParameterList().getParameters()) { result.add(Parameter(Identifier(parameter?.getName()!!), typeToType(parameter?.getType(), - ConverterUtil.isAnnotatedAsNotNull(parameter?.getModifierList())), - ConverterUtil.isReadOnly(parameter, method.getBody()))) + isAnnotatedAsNotNull(parameter?.getModifierList())), + isReadOnly(parameter, method.getBody()))) } return ParameterList(result) } @@ -413,7 +414,7 @@ public open class Converter() { public open fun parameterToParameter(parameter: PsiParameter): Parameter { return Parameter(Identifier(parameter.getName()!!), typeToType(parameter.getType(), - ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())), true) + isAnnotatedAsNotNull(parameter.getModifierList())), true) } public open fun argumentsToExpressionList(expression: PsiCallExpression): List { @@ -712,3 +713,117 @@ public open class Converter() { } } } + +public open fun createMainFunction(file: PsiFile): String { + val classNamesWithMains: List?> = arrayList() + for (c : PsiClass? in (file as PsiJavaFile).getClasses()) { + var main: PsiMethod? = findMainMethod(c) + if (main != null) { + classNamesWithMains.add(Pair(c?.getName(), main)) + } + } + + if (classNamesWithMains.size() > 0) { + var className: String? = classNamesWithMains.get(0)?.getFirst() + return MessageFormat.format("fun main(args : Array?) = {0}.main(args)", className)!! + } + + return "" + +} + +private fun findMainMethod(aClass: PsiClass?): PsiMethod? { + if (isMainClass(aClass)) { + val mainMethods: Array? = aClass?.findMethodsByName("main", false) + if (mainMethods != null) { + return findMainMethod(mainMethods) + } + } + return null +} + +private fun isMainClass(psiClass: PsiClass?): Boolean { + if (psiClass == null || psiClass is PsiAnonymousClass) + return false + + if (psiClass.isInterface()) + return false + + return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC) + +} + +private fun findMainMethod(mainMethods: Array): PsiMethod? { + return mainMethods.find { isMainMethod(it) } +} + +public open fun isMainMethod(method: PsiMethod?): Boolean { + if (method == null || method.getContainingClass() == null) + return false + + if (PsiType.VOID != method.getReturnType()) + return false + + if (!method.hasModifierProperty(PsiModifier.STATIC)) + return false + + if (!method.hasModifierProperty(PsiModifier.PUBLIC)) + return false + + val parameters: Array? = method.getParameterList().getParameters() + if (parameters?.size!! != 1) + return false + + val `type`: PsiType? = parameters!![0]?.getType() + if (`type` !is PsiArrayType) + return false + + val componentType: PsiType? = `type`.getComponentType() + return componentType?.equalsToText("java.lang.String")!! +} + +public open fun countWritingAccesses(element: PsiElement?, container: PsiElement?): Int { + var counter: Int = 0 + if (container != null) { + val visitor: ReferenceCollector = ReferenceCollector() + container.accept(visitor) + for (e : PsiReferenceExpression? in visitor.getCollectedReferences()) + if (e?.isReferenceTo(element)!! && PsiUtil.isAccessedForWriting(e)) { + counter++ + } + } + + return counter +} + +open class ReferenceCollector(): JavaRecursiveElementVisitor() { + private val myCollectedReferences: List = arrayList() + + public open fun getCollectedReferences(): List { + return myCollectedReferences + } + + public override fun visitReferenceExpression(expression: PsiReferenceExpression?): Unit { + super.visitReferenceExpression(expression) + if (expression != null) { + myCollectedReferences.add(expression) + } + } +} + +public open fun isReadOnly(element: PsiElement?, container: PsiElement?): Boolean { + return countWritingAccesses(element, container) == 0 +} + +public open fun isAnnotatedAsNotNull(modifierList: PsiModifierList?): Boolean { + if (modifierList != null) { + val annotations: Array? = modifierList.getAnnotations() + for (a : PsiAnnotation? in annotations) { + val qualifiedName: String? = a?.getQualifiedName() + if (qualifiedName != null && Converter.NOT_NULL_ANNOTATIONS.contains(qualifiedName)) { + return true + } + } + } + return false +} diff --git a/src/org/jetbrains/jet/j2k/ConverterUtil.java b/src/org/jetbrains/jet/j2k/ConverterUtil.java deleted file mode 100644 index c92c9a34b4c..00000000000 --- a/src/org/jetbrains/jet/j2k/ConverterUtil.java +++ /dev/null @@ -1,132 +0,0 @@ -/* - * Copyright 2010-2012 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.j2k; - -import com.intellij.openapi.util.Pair; -import com.intellij.psi.*; -import com.intellij.psi.util.PsiUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.text.MessageFormat; -import java.util.LinkedList; -import java.util.List; - -/** - * @author ignatov - */ -public class ConverterUtil { - private ConverterUtil() { - } - - @NotNull - public static String createMainFunction(@NotNull PsiFile file) { - List> classNamesWithMains = new LinkedList>(); - - for (PsiClass c : ((PsiJavaFile) file).getClasses()) { - PsiMethod main = findMainMethod(c); - if (main != null) { - classNamesWithMains.add(new Pair(c.getName(), main)); - } - } - if (classNamesWithMains.size() > 0) { - String className = classNamesWithMains.get(0).getFirst(); - return MessageFormat.format("fun main(args : Array?) = {0}.main(args)", className); - } - return ""; - } - - @Nullable - private static PsiMethod findMainMethod(@NotNull PsiClass aClass) { - if (isMainClass(aClass)) { - final PsiMethod[] mainMethods = aClass.findMethodsByName("main", false); - return findMainMethod(mainMethods); - } - return null; - } - - @Nullable - private static PsiMethod findMainMethod(@NotNull PsiMethod[] mainMethods) { - for (PsiMethod mainMethod : mainMethods) { - if (isMainMethod(mainMethod)) return mainMethod; - } - return null; - } - - private static boolean isMainClass(@NotNull PsiClass psiClass) { - if (psiClass instanceof PsiAnonymousClass) return false; - if (psiClass.isInterface()) return false; - return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC); - } - - public static boolean isMainMethod(@Nullable PsiMethod method) { - if (method == null || method.getContainingClass() == null) return false; - if (PsiType.VOID != method.getReturnType()) return false; - if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; - if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false; - final PsiParameter[] parameters = method.getParameterList().getParameters(); - if (parameters.length != 1) return false; - final PsiType type = parameters[0].getType(); - if (!(type instanceof PsiArrayType)) return false; - final PsiType componentType = ((PsiArrayType) type).getComponentType(); - return componentType.equalsToText("java.lang.String"); - } - - public static int countWritingAccesses(@Nullable PsiElement element, @Nullable PsiElement container) { - int counter = 0; - if (container != null) { - ReferenceCollector visitor = new ReferenceCollector(); - container.accept(visitor); - for (PsiReferenceExpression e : visitor.getCollectedReferences()) - if (e.isReferenceTo(element) && PsiUtil.isAccessedForWriting(e)) { - counter++; - } - } - return counter; - } - - public static boolean isReadOnly(PsiElement element, PsiElement container) { - return countWritingAccesses(element, container) == 0; - } - - public static boolean isAnnotatedAsNotNull(@Nullable PsiModifierList modifierList) { - if (modifierList != null) { - PsiAnnotation[] annotations = modifierList.getAnnotations(); - for (PsiAnnotation a : annotations) { - String qualifiedName = a.getQualifiedName(); - if (qualifiedName != null && Converter.$classobj.NOT_NULL_ANNOTATIONS.contains(qualifiedName)) { - return true; - } - } - } - return false; - } - - static class ReferenceCollector extends JavaRecursiveElementVisitor { - public List getCollectedReferences() { - return myCollectedReferences; - } - - private List myCollectedReferences = new LinkedList(); - - @Override - public void visitReferenceExpression(PsiReferenceExpression expression) { - super.visitReferenceExpression(expression); - myCollectedReferences.add(expression); - } - } -} diff --git a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt index f82f2d87875..05e38b0a918 100644 --- a/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt +++ b/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.kt @@ -5,7 +5,7 @@ import org.jetbrains.jet.j2k.Converter import org.jetbrains.jet.j2k.ast.* import org.jetbrains.jet.j2k.ast.types.Type import java.util.List -import org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull +import org.jetbrains.jet.j2k.isAnnotatedAsNotNull public open class ElementVisitor(val myConverter : Converter) : JavaElementVisitor() { protected var myResult : Element = Element.EMPTY_ELEMENT diff --git a/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt index 712c105cba2..afc4bd9aaed 100644 --- a/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt +++ b/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt @@ -9,7 +9,7 @@ import java.util.Arrays import java.util.Collections import java.util.LinkedList import java.util.List -import org.jetbrains.jet.j2k.ConverterUtil.countWritingAccesses +import org.jetbrains.jet.j2k.countWritingAccesses public open class StatementVisitor(converter: Converter): ElementVisitor(converter) { public override fun visitAssertStatement(statement: PsiAssertStatement?): Unit {