diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.java index 9cc875c21e3..b1821191b02 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.java @@ -10,10 +10,10 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.Messages; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; +import org.jetbrains.jet.j2k.Converter; import java.util.List; -import static org.jetbrains.jet.j2k.Converter.clearClassIdentifiers; import static org.jetbrains.jet.plugin.actions.JavaToKotlinActionUtil.*; /** @@ -22,6 +22,7 @@ import static org.jetbrains.jet.plugin.actions.JavaToKotlinActionUtil.*; public class JavaToKotlinAction extends AnAction { @Override public void actionPerformed(final AnActionEvent e) { + final Converter converter = new Converter(); VirtualFile[] virtualFiles = e.getData(PlatformDataKeys.VIRTUAL_FILE_ARRAY); final Project project = PlatformDataKeys.PROJECT.getData(e.getDataContext()); assert virtualFiles != null; @@ -33,10 +34,10 @@ public class JavaToKotlinAction extends AnAction { final boolean finalRemoveIt = needToRemoveFiles(result); final List allJavaFiles = getAllJavaFiles(virtualFiles, project); - clearClassIdentifiers(); + converter.clearClassIdentifiers(); for (PsiFile f : allJavaFiles) { if (f.getFileType() instanceof JavaFileType) { - setClassIdentifiers(f); + setClassIdentifiers(converter, f); } } @@ -46,7 +47,7 @@ public class JavaToKotlinAction extends AnAction { new Runnable() { @Override public void run() { - final List newFiles = performFiles(allJavaFilesNear); + final List newFiles = convertFiles(converter, allJavaFilesNear); if (finalRemoveIt) { deleteFiles(allJavaFilesNear); } diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java index 831874d25a8..fed0abbfe76 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java @@ -22,13 +22,11 @@ import java.util.*; * @author ignatov */ public class JavaToKotlinActionUtil { - private JavaToKotlinActionUtil() { - } - static void setClassIdentifiers(@NotNull PsiFile psiFile) { + static void setClassIdentifiers(@NotNull Converter converter, @NotNull PsiFile psiFile) { ClassVisitor c = new ClassVisitor(); psiFile.accept(c); - Converter.setClassIdentifiers(c.getClassIdentifiers()); + converter.setClassIdentifiers(c.getClassIdentifiers()); } @NotNull @@ -75,13 +73,13 @@ public class JavaToKotlinActionUtil { } @NotNull - static List performFiles(List allJavaFilesNear) { + static List convertFiles(final Converter converter, List allJavaFilesNear) { final List result = new LinkedList(); for (final PsiFile f : allJavaFilesNear) { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { - VirtualFile vf = performOneFile(f); + VirtualFile vf = convertOneFile(converter, f); if (vf != null) { result.add(vf); } @@ -110,13 +108,13 @@ public class JavaToKotlinActionUtil { } @Nullable - private static VirtualFile performOneFile(PsiFile psiFile) { + private static VirtualFile convertOneFile(Converter converter, PsiFile psiFile) { try { VirtualFile virtualFile = psiFile.getVirtualFile(); if (psiFile instanceof PsiJavaFile && virtualFile != null) { String result = ""; try { - result = Converter.fileToFile((PsiJavaFile) psiFile).toKotlin(); + result = converter.fileToFile((PsiJavaFile) psiFile).toKotlin(); } catch (Exception e) { //noinspection CallToPrintStackTrace e.printStackTrace(); diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.java b/j2k/src/org/jetbrains/jet/j2k/Converter.java index 5248e92d7af..6b9be85e4bb 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.java +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.java @@ -1,5 +1,6 @@ package org.jetbrains.jet.j2k; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; @@ -21,54 +22,55 @@ import static org.jetbrains.jet.j2k.visitors.TypeVisitor.*; */ public class Converter { @NotNull - final static Set NOT_NULL_ANNOTATIONS = new HashSet() { - { - add("org.jetbrains.annotations.NotNull"); - add("com.sun.istack.internal.NotNull"); - add("javax.annotation.Nonnull"); - } - }; + public static final Set NOT_NULL_ANNOTATIONS = ImmutableSet.of( + "org.jetbrains.annotations.NotNull", + "com.sun.istack.internal.NotNull", + "javax.annotation.Nonnull" + ); + @NotNull - private static Set ourClassIdentifiers = new HashSet(); + private Set classIdentifiers = Sets.newHashSet(); + @NotNull - private static final Dispatcher ourDispatcher = new Dispatcher(); + private final Dispatcher dispatcher = new Dispatcher(this); + @Nullable - private static PsiType ourMethodReturnType = null; + private PsiType methodReturnType = null; @NotNull - private static Set flags = Sets.newHashSet(); + private final Set flags = Sets.newHashSet(); - private Converter() { + public Converter() { } - public static boolean addFlag(@NotNull J2KConverterFlags flag) { + public boolean addFlag(@NotNull J2KConverterFlags flag) { return flags.add(flag); } - public static boolean hasFlag(@NotNull J2KConverterFlags flag) { + public boolean hasFlag(@NotNull J2KConverterFlags flag) { return flags.contains(flag); } - public static void setClassIdentifiers(@NotNull Set identifiers) { - ourClassIdentifiers = identifiers; + public void setClassIdentifiers(@NotNull Set identifiers) { + classIdentifiers = identifiers; } @NotNull - public static Set getClassIdentifiers() { - return new HashSet(ourClassIdentifiers); + public Set getClassIdentifiers() { + return Collections.unmodifiableSet(classIdentifiers); } @Nullable - public static PsiType getMethodReturnType() { - return ourMethodReturnType; + public PsiType getMethodReturnType() { + return methodReturnType; } - public static void clearClassIdentifiers() { - ourClassIdentifiers.clear(); + public void clearClassIdentifiers() { + classIdentifiers.clear(); } @NotNull - public static String elementToKotlin(@NotNull PsiElement element) { + public String elementToKotlin(@NotNull PsiElement element) { if (element instanceof PsiJavaFile) { return fileToFile((PsiJavaFile) element).toKotlin(); } @@ -98,17 +100,17 @@ public class Converter { } @NotNull - public static File fileToFile(@NotNull PsiJavaFile javaFile) { + public File fileToFile(@NotNull PsiJavaFile javaFile) { return fileToFile(javaFile, Collections.emptyList()); } @NotNull - public static File fileToFileWithCompatibilityImport(@NotNull PsiJavaFile javaFile) { + public File fileToFileWithCompatibilityImport(@NotNull PsiJavaFile javaFile) { return fileToFile(javaFile, Collections.singletonList("std.compatibility.*")); } @NotNull - private static File fileToFile(PsiJavaFile javaFile, List additionalImports) { + private File fileToFile(PsiJavaFile javaFile, List additionalImports) { final PsiImportList importList = javaFile.getImportList(); List imports = importList == null ? Collections.emptyList() @@ -127,19 +129,19 @@ public class Converter { } @NotNull - private static List classesToClassList(@NotNull PsiClass[] classes) { + private List classesToClassList(@NotNull PsiClass[] classes) { List result = new LinkedList(); for (PsiClass t : classes) result.add(classToClass(t)); return result; } @NotNull - public static AnonymousClass anonymousClassToAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) { - return new AnonymousClass(getMembers(anonymousClass)); + public AnonymousClass anonymousClassToAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) { + return new AnonymousClass(this, getMembers(anonymousClass)); } @NotNull - private static List getMembers(@NotNull PsiClass psiClass) { + private List getMembers(@NotNull PsiClass psiClass) { List members = new LinkedList(); for (PsiElement e : psiClass.getChildren()) { if (e instanceof PsiMethod) { @@ -198,7 +200,7 @@ public class Converter { } @NotNull - private static Class classToClass(@NotNull PsiClass psiClass) { + private Class classToClass(@NotNull PsiClass psiClass) { final Set modifiers = modifiersListToModifiersSet(psiClass.getModifierList()); final List fields = fieldsToFieldList(psiClass.getFields(), psiClass); final List typeParameters = elementsToElementList(psiClass.getTypeParameters()); @@ -285,16 +287,16 @@ public class Converter { } if (psiClass.isInterface()) { - return new Trait(name, modifiers, typeParameters, extendsTypes, Collections.emptyList(), implementsTypes, members); + return new Trait(this, name, modifiers, typeParameters, extendsTypes, Collections.emptyList(), implementsTypes, members); } if (psiClass.isEnum()) { - return new Enum(name, modifiers, typeParameters, Collections.emptyList(), Collections.emptyList(), implementsTypes, members); + return new Enum(this, name, modifiers, typeParameters, Collections.emptyList(), Collections.emptyList(), implementsTypes, members); } - return new Class(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members); + return new Class(this, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members); } @NotNull - private static Initializer initializerToInitializer(@NotNull PsiClassInitializer i) { + private Initializer initializerToInitializer(@NotNull PsiClassInitializer i) { return new Initializer( blockToBlock(i.getBody(), true), modifiersListToModifiersSet(i.getModifierList()) @@ -317,14 +319,14 @@ public class Converter { } @NotNull - private static List fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) { + private List fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) { List result = new LinkedList(); for (PsiField f : fields) result.add(fieldToField(f, psiClass)); return result; } @NotNull - private static Field fieldToField(@NotNull PsiField field, PsiClass psiClass) { + private Field fieldToField(@NotNull PsiField field, PsiClass psiClass) { Set modifiers = modifiersListToModifiersSet(field.getModifierList()); if (field instanceof PsiEnumConstant) // TODO: remove instanceof { @@ -378,20 +380,20 @@ public class Converter { } @NotNull - private static Function methodToFunction(@NotNull PsiMethod method) { + private Function methodToFunction(@NotNull PsiMethod method) { return methodToFunction(method, true); } @NotNull - private static Function methodToFunction(@NotNull PsiMethod method, boolean notEmpty) { + private Function methodToFunction(@NotNull PsiMethod method, boolean notEmpty) { if (isOverrideObjectDirect(method)) { - ourDispatcher.setExpressionVisitor(new ExpressionVisitorForDirectObjectInheritors()); + dispatcher.setExpressionVisitor(new ExpressionVisitorForDirectObjectInheritors(this)); } else { - ourDispatcher.setExpressionVisitor(new ExpressionVisitor()); + dispatcher.setExpressionVisitor(new ExpressionVisitor(this)); } - ourMethodReturnType = method.getReturnType(); + methodReturnType = method.getReturnType(); final IdentifierImpl identifier = new IdentifierImpl(method.getName()); final Type returnType = typeToType(method.getReturnType(), ConverterUtil.isAnnotatedAsNotNull(method.getModifierList())); @@ -435,7 +437,7 @@ public class Converter { } @NotNull - private static ParameterList createFunctionParameters(@NotNull PsiMethod method) { + private ParameterList createFunctionParameters(@NotNull PsiMethod method) { List result = new LinkedList(); for (PsiParameter parameter : method.getParameterList().getParameters()) { result.add(new Parameter( @@ -457,7 +459,7 @@ public class Converter { return false; } - private static boolean isOverrideAnyMethodExceptMethodsFromObject(@NotNull PsiMethod method) { + private boolean isOverrideAnyMethodExceptMethodsFromObject(@NotNull PsiMethod method) { boolean counter = normalCase(method); if (counter) { return true; @@ -468,7 +470,7 @@ public class Converter { return false; } - private static boolean caseForObject(@NotNull PsiMethod method) { + private boolean caseForObject(@NotNull PsiMethod method) { PsiClass containing = method.getContainingClass(); if (containing != null) { for (PsiClassType s : containing.getSuperTypes()) { @@ -518,85 +520,85 @@ public class Converter { } @NotNull - public static Block blockToBlock(@Nullable PsiCodeBlock block, boolean notEmpty) { + public Block blockToBlock(@Nullable PsiCodeBlock block, boolean notEmpty) { if (block == null) return Block.EMPTY_BLOCK; return new Block(statementsToStatementList(block.getStatements()), notEmpty); } @NotNull - public static Block blockToBlock(@Nullable PsiCodeBlock block) { + public Block blockToBlock(@Nullable PsiCodeBlock block) { return blockToBlock(block, true); } @NotNull - public static List statementsToStatementList(@NotNull PsiStatement[] statements) { + public List statementsToStatementList(@NotNull PsiStatement[] statements) { List result = new LinkedList(); for (PsiStatement t : statements) result.add(statementToStatement(t)); return result; } @NotNull - public static List statementsToStatementList(@NotNull List statements) { + public List statementsToStatementList(@NotNull List statements) { List result = new LinkedList(); for (PsiStatement t : statements) result.add(statementToStatement(t)); return result; } @NotNull - public static Statement statementToStatement(@Nullable PsiStatement s) { + public Statement statementToStatement(@Nullable PsiStatement s) { if (s == null) return Statement.EMPTY_STATEMENT; - final StatementVisitor statementVisitor = new StatementVisitor(); + final StatementVisitor statementVisitor = new StatementVisitor(this); s.accept(statementVisitor); return statementVisitor.getResult(); } @NotNull - public static List expressionsToExpressionList(@NotNull PsiExpression[] expressions) { + public List expressionsToExpressionList(@NotNull PsiExpression[] expressions) { List result = new LinkedList(); for (PsiExpression e : expressions) result.add(expressionToExpression(e)); return result; } @NotNull - public static Expression expressionToExpression(@Nullable PsiExpression e) { + public Expression expressionToExpression(@Nullable PsiExpression e) { if (e == null) return Expression.EMPTY_EXPRESSION; - final ExpressionVisitor expressionVisitor = ourDispatcher.getExpressionVisitor(); + final ExpressionVisitor expressionVisitor = dispatcher.getExpressionVisitor(); e.accept(expressionVisitor); return expressionVisitor.getResult(); } @NotNull - public static Element elementToElement(@Nullable PsiElement e) { + public Element elementToElement(@Nullable PsiElement e) { if (e == null) return Element.EMPTY_ELEMENT; - final ElementVisitor elementVisitor = new ElementVisitor(); + final ElementVisitor elementVisitor = new ElementVisitor(this); e.accept(elementVisitor); return elementVisitor.getResult(); } @NotNull - public static List elementsToElementList(@NotNull PsiElement[] elements) { + public List elementsToElementList(@NotNull PsiElement[] elements) { List result = new LinkedList(); for (PsiElement e : elements) result.add(elementToElement(e)); return result; } @NotNull - public static Type typeToType(@Nullable PsiType type) { + public Type typeToType(@Nullable PsiType type) { if (type == null) return Type.EMPTY_TYPE; - TypeVisitor typeVisitor = new TypeVisitor(); + TypeVisitor typeVisitor = new TypeVisitor(this); type.accept(typeVisitor); return typeVisitor.getResult(); } @NotNull - public static List typesToTypeList(@NotNull PsiType[] types) { + public List typesToTypeList(@NotNull PsiType[] types) { List result = new LinkedList(); for (PsiType t : types) result.add(typeToType(t)); return result; } @NotNull - public static Type typeToType(PsiType type, boolean notNull) { + public Type typeToType(PsiType type, boolean notNull) { Type result = typeToType(type); if (notNull) { result.convertedToNotNull(); @@ -605,7 +607,7 @@ public class Converter { } @NotNull - private static List typesToNotNullableTypeList(@NotNull PsiType[] types) { + private List typesToNotNullableTypeList(@NotNull PsiType[] types) { List result = new LinkedList(typesToTypeList(types)); for (Type p : result) p.convertedToNotNull(); return result; @@ -634,14 +636,14 @@ public class Converter { } @NotNull - public static List parametersToParameterList(@NotNull PsiParameter[] parameters) { + public List parametersToParameterList(@NotNull PsiParameter[] parameters) { List result = new LinkedList(); for (PsiParameter t : parameters) result.add(parameterToParameter(t)); return result; } @NotNull - public static Parameter parameterToParameter(@NotNull PsiParameter parameter) { + public Parameter parameterToParameter(@NotNull PsiParameter parameter) { return new Parameter( new IdentifierImpl(parameter.getName()), typeToType(parameter.getType(), ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())) @@ -670,7 +672,7 @@ public class Converter { } @NotNull - public static List createConversions(@NotNull PsiCallExpression expression) { + public List createConversions(@NotNull PsiCallExpression expression) { PsiExpressionList argumentList = expression.getArgumentList(); PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{}; List conversions = new LinkedList(); @@ -699,7 +701,7 @@ public class Converter { } @NotNull - public static List createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) { + public List createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) { PsiExpression[] arguments = expression.getOperands(); int length = arguments.length; List conversions = new LinkedList(); @@ -719,7 +721,7 @@ public class Converter { } @NotNull - private static String createConversionForExpression(@Nullable PsiExpression expression, @NotNull PsiType expectedType) { + private String createConversionForExpression(@Nullable PsiExpression expression, @NotNull PsiType expectedType) { String conversion = ""; if (expression != null) { PsiType actualType = expression.getType(); @@ -792,7 +794,7 @@ public class Converter { // } @NotNull - public static SureCallChainExpression createSureCallOnlyForChain(@Nullable PsiExpression expression, @NotNull PsiType type) { + public SureCallChainExpression createSureCallOnlyForChain(@Nullable PsiExpression expression, @NotNull PsiType type) { String conversion = (expression != null && (expression instanceof PsiReferenceExpression || expression instanceof PsiMethodCallExpression)) ? createConversionForExpression(expression, type) diff --git a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java index 5bb96ff6ca1..f7e098cfea6 100644 --- a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java +++ b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java @@ -41,6 +41,8 @@ public class JavaToKotlinTranslator { private JavaToKotlinTranslator() { } + private static final Converter CONVERTER = new Converter(); + @Nullable private static PsiFile createFile(@NotNull String text) { JavaCoreEnvironment javaCoreEnvironment = setUpJavaCoreEnvironment(); @@ -174,19 +176,19 @@ public class JavaToKotlinTranslator { return null; } - static void setClassIdentifiers(@NotNull PsiElement psiFile) { + static void setClassIdentifiers(@NotNull Converter converter, @NotNull PsiElement psiFile) { ClassVisitor c = new ClassVisitor(); psiFile.accept(c); - Converter.clearClassIdentifiers(); - Converter.setClassIdentifiers(c.getClassIdentifiers()); + converter.clearClassIdentifiers(); + converter.setClassIdentifiers(c.getClassIdentifiers()); } @NotNull static String generateKotlinCode(@NotNull String javaCode) { PsiFile file = createFile(javaCode); if (file != null && file instanceof PsiJavaFile) { - setClassIdentifiers(file); - return prettify(Converter.fileToFile((PsiJavaFile) file).toKotlin()); + setClassIdentifiers(CONVERTER, file); + return prettify(CONVERTER.fileToFile((PsiJavaFile) file).toKotlin()); } return ""; } @@ -195,8 +197,8 @@ public class JavaToKotlinTranslator { static String generateKotlinCodeWithCompatibilityImport(@NotNull String javaCode) { PsiFile file = createFile(javaCode); if (file != null && file instanceof PsiJavaFile) { - setClassIdentifiers(file); - return prettify(Converter.fileToFileWithCompatibilityImport((PsiJavaFile) file).toKotlin()); + setClassIdentifiers(CONVERTER, file); + return prettify(CONVERTER.fileToFileWithCompatibilityImport((PsiJavaFile) file).toKotlin()); } return ""; } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java index d171f533f51..68561e785cb 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.j2k.ast; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.j2k.Converter; import java.util.Collections; import java.util.List; @@ -9,14 +10,15 @@ import java.util.List; * @author ignatov */ public class AnonymousClass extends Class { - public AnonymousClass(List members) { - super(new IdentifierImpl("anonClass"), + public AnonymousClass(Converter converter, List members) { + super(converter, + new IdentifierImpl("anonClass"), Collections.emptySet(), Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), - getMembers(members) + getMembers(members, converter) ); } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Class.java b/j2k/src/org/jetbrains/jet/j2k/ast/Class.java index b9e6fb0687b..94cf8fba7cc 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Class.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Class.java @@ -26,7 +26,7 @@ public class Class extends Member { private final List myExtendsTypes; private final List myImplementsTypes; - public Class(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + public Class(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, List baseClassParams, List implementsTypes, List members) { myName = name; myBaseClassParams = baseClassParams; @@ -34,12 +34,12 @@ public class Class extends Member { myTypeParameters = typeParameters; myExtendsTypes = extendsTypes; myImplementsTypes = implementsTypes; - myMembers = getMembers(members); + myMembers = getMembers(members, converter); } - static List getMembers(List members) { + /*package*/ static List getMembers(List members, Converter converter) { List withoutPrivate = new LinkedList(); - if (Converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS)) { + if (converter.hasFlag(J2KConverterFlags.SKIP_NON_PUBLIC_MEMBERS)) { for (Member m : members) { if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) { withoutPrivate.add(m); diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java index ca61fcebbb0..2a8ead90afc 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.j2k.ast; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.j2k.Converter; import org.jetbrains.jet.j2k.util.AstUtil; import java.util.List; @@ -10,9 +11,9 @@ import java.util.Set; * @author ignatov */ public class Enum extends Class { - public Enum(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + public Enum(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, List baseClassParams, List implementsTypes, List members) { - super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members)); + super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter)); } String primaryConstructorSignatureToKotlin() { diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java index 3c0172912ef..59db00e742d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java @@ -1,5 +1,7 @@ package org.jetbrains.jet.j2k.ast; +import org.jetbrains.jet.j2k.Converter; + import java.util.List; import java.util.Set; @@ -7,9 +9,9 @@ import java.util.Set; * @author ignatov */ public class Trait extends Class { - public Trait(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + public Trait(Converter converter, Identifier name, Set modifiers, List typeParameters, List extendsTypes, List baseClassParams, List implementsTypes, List members) { - super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members)); + super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter)); TYPE = "trait"; } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java index 8da473b81be..e44fcc6db57 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java @@ -1,5 +1,8 @@ package org.jetbrains.jet.j2k.visitors; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.j2k.Converter; + /** * @author ignatov */ @@ -10,8 +13,8 @@ public class Dispatcher { this.myExpressionVisitor = expressionVisitor; } - public Dispatcher() { - myExpressionVisitor = new ExpressionVisitor(); + public Dispatcher(@NotNull Converter converter) { + myExpressionVisitor = new ExpressionVisitor(converter); } public ExpressionVisitor getExpressionVisitor() { diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java index 12f7591b98e..3531e8f0822 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.j2k.visitors; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.j2k.Converter; import org.jetbrains.jet.j2k.ast.*; import java.util.List; @@ -12,10 +13,23 @@ import static org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull; /** * @author ignatov */ -public class ElementVisitor extends JavaElementVisitor { +public class ElementVisitor extends JavaElementVisitor implements J2KVisitor { + + private final Converter myConverter; + @NotNull private Element myResult = Element.EMPTY_ELEMENT; + public ElementVisitor(@NotNull Converter converter) { + this.myConverter = converter; + } + + @Override + @NotNull + public Converter getConverter() { + return myConverter; + } + @NotNull public Element getResult() { return myResult; @@ -28,8 +42,8 @@ public class ElementVisitor extends JavaElementVisitor { myResult = new LocalVariable( new IdentifierImpl(variable.getName()), // TODO modifiersListToModifiersSet(variable.getModifierList()), - typeToType(variable.getType(), isAnnotatedAsNotNull(variable.getModifierList())), - createSureCallOnlyForChain(variable.getInitializer(), variable.getType()) + getConverter().typeToType(variable.getType(), isAnnotatedAsNotNull(variable.getModifierList())), + getConverter().createSureCallOnlyForChain(variable.getInitializer(), variable.getType()) ); } @@ -37,8 +51,8 @@ public class ElementVisitor extends JavaElementVisitor { public void visitExpressionList(@NotNull PsiExpressionList list) { super.visitExpressionList(list); myResult = new ExpressionList( - expressionsToExpressionList(list.getExpressions()), - typesToTypeList(list.getExpressionTypes()) + getConverter().expressionsToExpressionList(list.getExpressions()), + getConverter().typesToTypeList(list.getExpressionTypes()) ); } @@ -46,7 +60,7 @@ public class ElementVisitor extends JavaElementVisitor { public void visitReferenceElement(@NotNull PsiJavaCodeReferenceElement reference) { super.visitReferenceElement(reference); - final List types = typesToTypeList(reference.getTypeParameters()); + final List types = getConverter().typesToTypeList(reference.getTypeParameters()); if (!reference.isQualified()) { myResult = new ReferenceElement( new IdentifierImpl(reference.getReferenceName()), @@ -71,7 +85,7 @@ public class ElementVisitor extends JavaElementVisitor { @Override public void visitTypeElement(@NotNull PsiTypeElement type) { super.visitTypeElement(type); - myResult = new TypeElement(typeToType(type.getType())); + myResult = new TypeElement(getConverter().typeToType(type.getType())); } @Override @@ -79,7 +93,7 @@ public class ElementVisitor extends JavaElementVisitor { super.visitTypeParameter(classParameter); myResult = new TypeParameter( new IdentifierImpl(classParameter.getName()), // TODO - typesToTypeList(classParameter.getExtendsListTypes()) + getConverter().typesToTypeList(classParameter.getExtendsListTypes()) ); } @@ -87,7 +101,7 @@ public class ElementVisitor extends JavaElementVisitor { public void visitParameterList(@NotNull PsiParameterList list) { super.visitParameterList(list); myResult = new ParameterList( - parametersToParameterList(list.getParameters()) + getConverter().parametersToParameterList(list.getParameters()) ); } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java index 5cd5c247f83..9c4c47d79af 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java @@ -4,6 +4,7 @@ import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.j2k.Converter; import org.jetbrains.jet.j2k.ast.*; import java.util.Collections; @@ -19,6 +20,10 @@ public class ExpressionVisitor extends StatementVisitor { @NotNull Expression myResult = Expression.EMPTY_EXPRESSION; + public ExpressionVisitor(@NotNull Converter converter) { + super(converter); + } + @Override public void visitExpression(final PsiExpression expression) { myResult = Expression.EMPTY_EXPRESSION; @@ -34,8 +39,8 @@ public class ExpressionVisitor extends StatementVisitor { public void visitArrayAccessExpression(@NotNull PsiArrayAccessExpression expression) { super.visitArrayAccessExpression(expression); myResult = new ArrayAccessExpression( - expressionToExpression(expression.getArrayExpression()), - expressionToExpression(expression.getIndexExpression()) + getConverter().expressionToExpression(expression.getArrayExpression()), + getConverter().expressionToExpression(expression.getIndexExpression()) ); } @@ -43,8 +48,8 @@ public class ExpressionVisitor extends StatementVisitor { public void visitArrayInitializerExpression(@NotNull PsiArrayInitializerExpression expression) { super.visitArrayInitializerExpression(expression); myResult = new ArrayInitializerExpression( - typeToType(expression.getType()), - expressionsToExpressionList(expression.getInitializers()) + getConverter().typeToType(expression.getType()), + getConverter().expressionsToExpressionList(expression.getInitializers()) ); } @@ -67,10 +72,10 @@ public class ExpressionVisitor extends StatementVisitor { if (!secondOp.isEmpty()) // if not Kotlin operators { myResult = new AssignmentExpression( - expressionToExpression(expression.getLExpression()), + getConverter().expressionToExpression(expression.getLExpression()), new BinaryExpression( - expressionToExpression(expression.getLExpression()), - expressionToExpression(expression.getRExpression()), + getConverter().expressionToExpression(expression.getLExpression()), + getConverter().expressionToExpression(expression.getRExpression()), secondOp ), "=" @@ -78,8 +83,8 @@ public class ExpressionVisitor extends StatementVisitor { } else { myResult = new AssignmentExpression( - expressionToExpression(expression.getLExpression()), - expressionToExpression(expression.getRExpression()), + getConverter().expressionToExpression(expression.getLExpression()), + getConverter().expressionToExpression(expression.getRExpression()), expression.getOperationSign().getText() // TODO ); } @@ -120,17 +125,17 @@ public class ExpressionVisitor extends StatementVisitor { if (expression.getOperationSign().getTokenType() == JavaTokenType.GTGTGT) { myResult = new DummyMethodCallExpression( - expressionToExpression(expression.getLOperand()), + getConverter().expressionToExpression(expression.getLOperand()), "ushr", - expressionToExpression(expression.getROperand())); + getConverter().expressionToExpression(expression.getROperand())); } else { myResult = new BinaryExpression( - expressionToExpression(expression.getLOperand()), - expressionToExpression(expression.getROperand()), + getConverter().expressionToExpression(expression.getLOperand()), + getConverter().expressionToExpression(expression.getROperand()), getOperatorString(expression.getOperationSign().getTokenType()), - createConversions(expression, PsiType.BOOLEAN) + getConverter().createConversions(expression, PsiType.BOOLEAN) ); } } @@ -138,7 +143,7 @@ public class ExpressionVisitor extends StatementVisitor { @Override public void visitClassObjectAccessExpression(@NotNull PsiClassObjectAccessExpression expression) { super.visitClassObjectAccessExpression(expression); - myResult = new ClassObjectAccessExpression(elementToElement(expression.getOperand())); + myResult = new ClassObjectAccessExpression(getConverter().elementToElement(expression.getOperand())); } @Override @@ -147,13 +152,13 @@ public class ExpressionVisitor extends StatementVisitor { PsiExpression condition = expression.getCondition(); PsiType type = condition.getType(); Expression e = type != null ? - createSureCallOnlyForChain(condition, type) : - expressionToExpression(condition); + getConverter().createSureCallOnlyForChain(condition, type) : + getConverter().expressionToExpression(condition); myResult = new ParenthesizedExpression( new IfStatement( e, - expressionToExpression(expression.getThenExpression()), - expressionToExpression(expression.getElseExpression()) + getConverter().expressionToExpression(expression.getThenExpression()), + getConverter().expressionToExpression(expression.getElseExpression()) ) ); } @@ -161,15 +166,15 @@ public class ExpressionVisitor extends StatementVisitor { @Override public void visitExpressionList(@NotNull PsiExpressionList list) { super.visitExpressionList(list); - myResult = new ExpressionList(expressionsToExpressionList(list.getExpressions())); + myResult = new ExpressionList(getConverter().expressionsToExpressionList(list.getExpressions())); } @Override public void visitInstanceOfExpression(@NotNull PsiInstanceOfExpression expression) { super.visitInstanceOfExpression(expression); myResult = new IsOperator( - expressionToExpression(expression.getOperand()), - elementToElement(expression.getCheckType())); + getConverter().expressionToExpression(expression.getOperand()), + getConverter().elementToElement(expression.getCheckType())); } @Override @@ -213,11 +218,11 @@ public class ExpressionVisitor extends StatementVisitor { if (!SuperVisitor.isSuper(expression.getMethodExpression()) || !isInsidePrimaryConstructor(expression)) { myResult = // TODO: not resolved new MethodCallExpression( - expressionToExpression(expression.getMethodExpression()), - expressionsToExpressionList(expression.getArgumentList().getExpressions()), - createConversions(expression), - typeToType(expression.getType()).isNullable(), - typesToTypeList(expression.getTypeArguments()) + getConverter().expressionToExpression(expression.getMethodExpression()), + getConverter().expressionsToExpressionList(expression.getArgumentList().getExpressions()), + getConverter().createConversions(expression), + getConverter().typeToType(expression.getType()).isNullable(), + getConverter().typesToTypeList(expression.getTypeArguments()) ); } } @@ -243,53 +248,53 @@ public class ExpressionVisitor extends StatementVisitor { } @NotNull - private static Expression createNewClassExpression(@NotNull PsiNewExpression expression) { + private Expression createNewClassExpression(@NotNull PsiNewExpression expression) { final PsiAnonymousClass anonymousClass = expression.getAnonymousClass(); final PsiMethod constructor = expression.resolveMethod(); PsiJavaCodeReferenceElement classReference = expression.getClassOrAnonymousClassReference(); - final boolean isNotConvertedClass = classReference != null && !getClassIdentifiers().contains(classReference.getQualifiedName()); + final boolean isNotConvertedClass = classReference != null && !getConverter().getClassIdentifiers().contains(classReference.getQualifiedName()); PsiExpressionList argumentList = expression.getArgumentList(); PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{}; if (constructor == null || isConstructorPrimary(constructor) || isNotConvertedClass) { return new NewClassExpression( - expressionToExpression(expression.getQualifier()), - elementToElement(classReference), - expressionsToExpressionList(arguments), - createConversions(expression), - anonymousClass != null ? anonymousClassToAnonymousClass(anonymousClass) : null + getConverter().expressionToExpression(expression.getQualifier()), + getConverter().elementToElement(classReference), + getConverter().expressionsToExpressionList(arguments), + getConverter().createConversions(expression), + anonymousClass != null ? getConverter().anonymousClassToAnonymousClass(anonymousClass) : null ); } // is constructor secondary final PsiJavaCodeReferenceElement reference = expression.getClassReference(); final List typeParameters = reference != null - ? typesToTypeList(reference.getTypeParameters()) + ? getConverter().typesToTypeList(reference.getTypeParameters()) : Collections.emptyList(); return new CallChainExpression( new IdentifierImpl(constructor.getName(), false), new MethodCallExpression( new IdentifierImpl("init"), - expressionsToExpressionList(arguments), + getConverter().expressionsToExpressionList(arguments), typeParameters)); } @NotNull - private static Expression createNewEmptyArrayWithoutInitialization(@NotNull PsiNewExpression expression) { + private Expression createNewEmptyArrayWithoutInitialization(@NotNull PsiNewExpression expression) { return new ArrayWithoutInitializationExpression( - typeToType(expression.getType(), true), - expressionsToExpressionList(expression.getArrayDimensions()) + getConverter().typeToType(expression.getType(), true), + getConverter().expressionsToExpressionList(expression.getArrayDimensions()) ); } @NotNull - private static Expression createNewEmptyArray(@NotNull PsiNewExpression expression) { - return expressionToExpression(expression.getArrayInitializer()); + private Expression createNewEmptyArray(@NotNull PsiNewExpression expression) { + return getConverter().expressionToExpression(expression.getArrayInitializer()); } @Override public void visitParenthesizedExpression(@NotNull PsiParenthesizedExpression expression) { super.visitParenthesizedExpression(expression); myResult = new ParenthesizedExpression( - expressionToExpression(expression.getExpression()) + getConverter().expressionToExpression(expression.getExpression()) ); } @@ -298,7 +303,7 @@ public class ExpressionVisitor extends StatementVisitor { super.visitPostfixExpression(expression); myResult = new PostfixOperator( getOperatorString(expression.getOperationSign().getTokenType()), - expressionToExpression(expression.getOperand()) + getConverter().expressionToExpression(expression.getOperand()) ); } @@ -307,13 +312,13 @@ public class ExpressionVisitor extends StatementVisitor { super.visitPrefixExpression(expression); if (expression.getOperationTokenType() == JavaTokenType.TILDE) { myResult = new DummyMethodCallExpression( - new ParenthesizedExpression(expressionToExpression(expression.getOperand())), "inv", Expression.EMPTY_EXPRESSION + new ParenthesizedExpression(getConverter().expressionToExpression(expression.getOperand())), "inv", Expression.EMPTY_EXPRESSION ); } else { myResult = new PrefixOperator( getOperatorString(expression.getOperationSign().getTokenType()), - expressionToExpression(expression.getOperand()) + getConverter().expressionToExpression(expression.getOperand()) ); } } @@ -326,7 +331,7 @@ public class ExpressionVisitor extends StatementVisitor { final boolean insideSecondaryConstructor = isInsideSecondaryConstructor(expression); final boolean hasReceiver = isFieldReference && insideSecondaryConstructor; final boolean isThis = isThisExpression(expression); - final boolean isNullable = typeToType(expression.getType()).isNullable(); + final boolean isNullable = getConverter().typeToType(expression.getType()).isNullable(); final String className = getClassNameWithConstructor(expression); Expression identifier = new IdentifierImpl(expression.getReferenceName(), isNullable); @@ -340,7 +345,7 @@ public class ExpressionVisitor extends StatementVisitor { } myResult = new CallChainExpression( - expressionToExpression(expression.getQualifierExpression()), + getConverter().expressionToExpression(expression.getQualifierExpression()), identifier // TODO: if type exists so identifier is nullable ); } @@ -466,8 +471,8 @@ public class ExpressionVisitor extends StatementVisitor { final PsiTypeElement castType = expression.getCastType(); if (castType != null) { myResult = new TypeCastExpression( - typeToType(castType.getType()), - expressionToExpression(expression.getOperand()) + getConverter().typeToType(castType.getType()), + getConverter().expressionToExpression(expression.getOperand()) ); } } @@ -476,9 +481,9 @@ public class ExpressionVisitor extends StatementVisitor { public void visitPolyadicExpression(@NotNull PsiPolyadicExpression expression) { super.visitPolyadicExpression(expression); myResult = new PolyadicExpression( - expressionsToExpressionList(expression.getOperands()), + getConverter().expressionsToExpressionList(expression.getOperands()), getOperatorString(expression.getOperationTokenType()), - createConversions(expression, PsiType.BOOLEAN) + getConverter().createConversions(expression, PsiType.BOOLEAN) ); } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java index e14a2013711..a231ce268dd 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java @@ -13,13 +13,17 @@ import static org.jetbrains.jet.j2k.visitors.TypeVisitor.JAVA_LANG_OBJECT; * @author ignatov */ public class ExpressionVisitorForDirectObjectInheritors extends ExpressionVisitor { + public ExpressionVisitorForDirectObjectInheritors(@NotNull Converter converter) { + super(converter); + } + @Override public void visitMethodCallExpression(@NotNull final PsiMethodCallExpression expression) { if (superMethodInvocation(expression.getMethodExpression(), "hashCode")) { myResult = new DummyMethodCallExpression(new IdentifierImpl("System"), "identityHashCode", new IdentifierImpl("this")); } else if (superMethodInvocation(expression.getMethodExpression(), "equals")) { - myResult = new DummyMethodCallExpression(new IdentifierImpl("this"), "identityEquals", Converter.elementToElement(expression.getArgumentList())); + myResult = new DummyMethodCallExpression(new IdentifierImpl("this"), "identityEquals", getConverter().elementToElement(expression.getArgumentList())); } else if (superMethodInvocation(expression.getMethodExpression(), "toString")) { myResult = new DummyStringExpression(String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())", getClassName(expression.getMethodExpression()))); diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/J2KVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/J2KVisitor.java new file mode 100644 index 00000000000..e6688d1a469 --- /dev/null +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/J2KVisitor.java @@ -0,0 +1,12 @@ +package org.jetbrains.jet.j2k.visitors; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.j2k.Converter; + +/** + * @author abreslav + */ +public interface J2KVisitor { + @NotNull + Converter getConverter(); +} diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java index 4941ab24324..50881bed506 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java @@ -21,6 +21,10 @@ import static org.jetbrains.jet.j2k.ConverterUtil.countWritingAccesses; public class StatementVisitor extends ElementVisitor { private Statement myResult = Statement.EMPTY_STATEMENT; + public StatementVisitor(@NotNull Converter converter) { + super(converter); + } + @NotNull @Override public Statement getResult() { @@ -31,8 +35,8 @@ public class StatementVisitor extends ElementVisitor { public void visitAssertStatement(@NotNull PsiAssertStatement statement) { super.visitAssertStatement(statement); myResult = new AssertStatement( - expressionToExpression(statement.getAssertCondition()), - expressionToExpression(statement.getAssertDescription()) + getConverter().expressionToExpression(statement.getAssertCondition()), + getConverter().expressionToExpression(statement.getAssertDescription()) ); } @@ -40,7 +44,7 @@ public class StatementVisitor extends ElementVisitor { public void visitBlockStatement(@NotNull PsiBlockStatement statement) { super.visitBlockStatement(statement); myResult = new Block( - statementsToStatementList(statement.getCodeBlock().getStatements()), + getConverter().statementsToStatementList(statement.getCodeBlock().getStatements()), true ); } @@ -75,7 +79,7 @@ public class StatementVisitor extends ElementVisitor { public void visitDeclarationStatement(@NotNull PsiDeclarationStatement statement) { super.visitDeclarationStatement(statement); myResult = new DeclarationStatement( - elementsToElementList(statement.getDeclaredElements()) + getConverter().elementsToElementList(statement.getDeclaredElements()) ); } @@ -85,25 +89,25 @@ public class StatementVisitor extends ElementVisitor { PsiExpression condition = statement.getCondition(); @SuppressWarnings("ConstantConditions") Expression expression = condition != null && condition.getType() != null ? - createSureCallOnlyForChain(condition, condition.getType()) : - expressionToExpression(condition); + getConverter().createSureCallOnlyForChain(condition, condition.getType()) : + getConverter().expressionToExpression(condition); myResult = new DoWhileStatement( expression, - statementToStatement(statement.getBody()) + getConverter().statementToStatement(statement.getBody()) ); } @Override public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) { super.visitExpressionStatement(statement); - myResult = expressionToExpression(statement.getExpression()); + myResult = getConverter().expressionToExpression(statement.getExpression()); } @Override public void visitExpressionListStatement(@NotNull PsiExpressionListStatement statement) { super.visitExpressionListStatement(statement); myResult = - new ExpressionListStatement(expressionsToExpressionList(statement.getExpressionList().getExpressions())); + new ExpressionListStatement(getConverter().expressionsToExpressionList(statement.getExpressionList().getExpressions())); } @Override @@ -143,25 +147,25 @@ public class StatementVisitor extends ElementVisitor { && firstChild.getNameIdentifier() != null && onceWritableIterator ) { - final Expression end = expressionToExpression(((PsiBinaryExpression) condition).getROperand()); + final Expression end = getConverter().expressionToExpression(((PsiBinaryExpression) condition).getROperand()); final Expression endExpression = operationTokenType == JavaTokenType.LT ? new BinaryExpression(end, new IdentifierImpl("1"), "-") : end; myResult = new ForeachWithRangeStatement( new IdentifierImpl(firstChild.getName()), - expressionToExpression(firstChild.getInitializer()), + getConverter().expressionToExpression(firstChild.getInitializer()), endExpression, - statementToStatement(body) + getConverter().statementToStatement(body) ); } else { // common case: while loop instead of for loop List forStatements = new LinkedList(); - forStatements.add(statementToStatement(initialization)); + forStatements.add(getConverter().statementToStatement(initialization)); forStatements.add(new WhileStatement( - expressionToExpression(condition), + getConverter().expressionToExpression(condition), new Block( - Arrays.asList(statementToStatement(body), - new Block(Arrays.asList(statementToStatement(update))))))); + Arrays.asList(getConverter().statementToStatement(body), + new Block(Arrays.asList(getConverter().statementToStatement(update))))))); myResult = new Block(forStatements); } } @@ -175,9 +179,9 @@ public class StatementVisitor extends ElementVisitor { public void visitForeachStatement(@NotNull PsiForeachStatement statement) { super.visitForeachStatement(statement); myResult = new ForeachStatement( - parameterToParameter(statement.getIterationParameter()), - expressionToExpression(statement.getIteratedValue()), - statementToStatement(statement.getBody()) + getConverter().parameterToParameter(statement.getIterationParameter()), + getConverter().expressionToExpression(statement.getIteratedValue()), + getConverter().statementToStatement(statement.getBody()) ); } @@ -187,12 +191,12 @@ public class StatementVisitor extends ElementVisitor { PsiExpression condition = statement.getCondition(); @SuppressWarnings("ConstantConditions") Expression expression = condition != null && condition.getType() != null ? - createSureCallOnlyForChain(condition, condition.getType()) : - expressionToExpression(condition); + getConverter().createSureCallOnlyForChain(condition, condition.getType()) : + getConverter().expressionToExpression(condition); myResult = new IfStatement( expression, - statementToStatement(statement.getThenBranch()), - statementToStatement(statement.getElseBranch()) + getConverter().statementToStatement(statement.getThenBranch()), + getConverter().statementToStatement(statement.getElseBranch()) ); } @@ -201,7 +205,7 @@ public class StatementVisitor extends ElementVisitor { super.visitLabeledStatement(statement); myResult = new LabelStatement( identifierToIdentifier(statement.getLabelIdentifier()), - statementToStatement(statement.getStatement()) + getConverter().statementToStatement(statement.getStatement()) ); } @@ -210,20 +214,20 @@ public class StatementVisitor extends ElementVisitor { super.visitSwitchLabelStatement(statement); myResult = statement.isDefaultCase() ? new DefaultSwitchLabelStatement() : - new SwitchLabelStatement(expressionToExpression(statement.getCaseValue())); + new SwitchLabelStatement(getConverter().expressionToExpression(statement.getCaseValue())); } @Override public void visitSwitchStatement(@NotNull PsiSwitchStatement statement) { super.visitSwitchStatement(statement); myResult = new SwitchContainer( - expressionToExpression(statement.getExpression()), + getConverter().expressionToExpression(statement.getExpression()), switchBodyToCases(statement.getBody()) ); } @NotNull - private static List switchBodyToCases(@Nullable final PsiCodeBlock body) { + private List switchBodyToCases(@Nullable final PsiCodeBlock body) { final List> cases = splitToCases(body); final List allSwitchStatements = body != null ? Arrays.asList(body.getStatements()) @@ -240,25 +244,25 @@ public class StatementVisitor extends ElementVisitor { assert allSwitchStatements.get(i) == label : "not a right index"; if (ls.size() > 1) { - pendingLabels.add(statementToStatement(label)); + pendingLabels.add(getConverter().statementToStatement(label)); List slice = ls.subList(1, ls.size()); if (!containsBreak(slice)) { - List statements = statementsToStatementList(slice); + List statements = getConverter().statementsToStatementList(slice); statements.addAll( - statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size())) + getConverter().statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size())) ); result.add(new CaseContainer(pendingLabels, statements)); pendingLabels = new LinkedList(); } else { - result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice))); + result.add(new CaseContainer(pendingLabels, getConverter().statementsToStatementList(slice))); pendingLabels = new LinkedList(); } } else // ls.size() == 1 { - pendingLabels.add(statementToStatement(label)); + pendingLabels.add(getConverter().statementToStatement(label)); } i += ls.size(); } @@ -315,8 +319,8 @@ public class StatementVisitor extends ElementVisitor { public void visitSynchronizedStatement(@NotNull PsiSynchronizedStatement statement) { super.visitSynchronizedStatement(statement); myResult = new SynchronizedStatement( - expressionToExpression(statement.getLockExpression()), - blockToBlock(statement.getBody()) + getConverter().expressionToExpression(statement.getLockExpression()), + getConverter().blockToBlock(statement.getBody()) ); } @@ -324,7 +328,7 @@ public class StatementVisitor extends ElementVisitor { public void visitThrowStatement(@NotNull PsiThrowStatement statement) { super.visitThrowStatement(statement); myResult = new ThrowStatement( - expressionToExpression(statement.getException()) + getConverter().expressionToExpression(statement.getException()) ); } @@ -335,15 +339,15 @@ public class StatementVisitor extends ElementVisitor { List catches = new LinkedList(); for (int i = 0; i < statement.getCatchBlocks().length; i++) { catches.add(new CatchStatement( - parameterToParameter(statement.getCatchBlockParameters()[i]), - blockToBlock(statement.getCatchBlocks()[i], true) + getConverter().parameterToParameter(statement.getCatchBlockParameters()[i]), + getConverter().blockToBlock(statement.getCatchBlocks()[i], true) )); } myResult = new TryStatement( - blockToBlock(statement.getTryBlock(), true), + getConverter().blockToBlock(statement.getTryBlock(), true), catches, - blockToBlock(statement.getFinallyBlock(), true) + getConverter().blockToBlock(statement.getFinallyBlock(), true) ); } @@ -353,11 +357,11 @@ public class StatementVisitor extends ElementVisitor { PsiExpression condition = statement.getCondition(); @SuppressWarnings("ConstantConditions") Expression expression = condition != null && condition.getType() != null ? - createSureCallOnlyForChain(condition, condition.getType()) : - expressionToExpression(condition); + getConverter().createSureCallOnlyForChain(condition, condition.getType()) : + getConverter().expressionToExpression(condition); myResult = new WhileStatement( expression, - statementToStatement(statement.getBody()) + getConverter().statementToStatement(statement.getBody()) ); } @@ -365,10 +369,10 @@ public class StatementVisitor extends ElementVisitor { public void visitReturnStatement(@NotNull PsiReturnStatement statement) { super.visitReturnStatement(statement); PsiExpression returnValue = statement.getReturnValue(); - PsiType methodReturnType = Converter.getMethodReturnType(); + PsiType methodReturnType = getConverter().getMethodReturnType(); Expression expression = returnValue != null && methodReturnType != null ? - createSureCallOnlyForChain(returnValue, methodReturnType) : - expressionToExpression(returnValue); + getConverter().createSureCallOnlyForChain(returnValue, methodReturnType) : + getConverter().expressionToExpression(returnValue); myResult = new ReturnStatement( expression ); diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java index dd1a83a8959..1303fc1b6f3 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java @@ -1,17 +1,18 @@ package org.jetbrains.jet.j2k.visitors; +import com.google.common.collect.Sets; import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.HashSet; +import java.util.Set; /** * @author ignatov */ public class ThisVisitor extends JavaRecursiveElementVisitor { @NotNull - private final HashSet myResolvedConstructors = new HashSet(); + private final Set myResolvedConstructors = Sets.newLinkedHashSet(); @Override public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) { diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java index 4863ae1249c..af048c2a9f8 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java @@ -11,13 +11,10 @@ import org.jetbrains.jet.j2k.util.AstUtil; import java.util.LinkedList; import java.util.List; -import static org.jetbrains.jet.j2k.Converter.typeToType; -import static org.jetbrains.jet.j2k.Converter.typesToTypeList; - /** * @author ignatov */ -public class TypeVisitor extends PsiTypeVisitor { +public class TypeVisitor extends PsiTypeVisitor implements J2KVisitor { public static final String JAVA_LANG_BYTE = "java.lang.Byte"; public static final String JAVA_LANG_CHARACTER = "java.lang.Character"; public static final String JAVA_LANG_DOUBLE = "java.lang.Double"; @@ -30,8 +27,13 @@ public class TypeVisitor extends PsiTypeVisitor { public static final String JAVA_LANG_STRING = "java.lang.String"; private static final String JAVA_LANG_ITERABLE = "java.lang.Iterable"; private static final String JAVA_UTIL_ITERATOR = "java.util.Iterator"; + private final Converter myConverter; private Type myResult = Type.EMPTY_TYPE; + public TypeVisitor(@NotNull Converter myConverter) { + this.myConverter = myConverter; + } + @NotNull public Type getResult() { return myResult; @@ -57,7 +59,7 @@ public class TypeVisitor extends PsiTypeVisitor { @Override public Type visitArrayType(@NotNull PsiArrayType arrayType) { if (myResult == Type.EMPTY_TYPE) { - myResult = new ArrayType(typeToType(arrayType.getComponentType())); + myResult = new ArrayType(getConverter().typeToType(arrayType.getComponentType())); } return super.visitArrayType(arrayType); } @@ -71,18 +73,18 @@ public class TypeVisitor extends PsiTypeVisitor { myResult = new ClassType(identifier, resolvedClassTypeParams); } else { - myResult = new ClassType(identifier, typesToTypeList(classType.getParameters())); + myResult = new ClassType(identifier, getConverter().typesToTypeList(classType.getParameters())); } return super.visitClassType(classType); } @NotNull - private static IdentifierImpl constructClassTypeIdentifier(@NotNull PsiClassType classType) { + private IdentifierImpl constructClassTypeIdentifier(@NotNull PsiClassType classType) { final PsiClass psiClass = classType.resolve(); if (psiClass != null) { String qualifiedName = psiClass.getQualifiedName(); if (qualifiedName != null) { - if (!qualifiedName.equals("java.lang.Object") && Converter.hasFlag(J2KConverterFlags.FULLY_QUALIFIED_TYPE_NAMES)) { + if (!qualifiedName.equals("java.lang.Object") && getConverter().hasFlag(J2KConverterFlags.FULLY_QUALIFIED_TYPE_NAMES)) { return new IdentifierImpl(qualifiedName); } if (qualifiedName.equals(JAVA_LANG_ITERABLE)) { @@ -122,7 +124,7 @@ public class TypeVisitor extends PsiTypeVisitor { } @NotNull - private static List createRawTypesForResolvedReference(@NotNull PsiClassType classType) { + private List createRawTypesForResolvedReference(@NotNull PsiClassType classType) { final List typeParams = new LinkedList(); if (classType instanceof PsiClassReferenceType) { final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference(); @@ -133,7 +135,7 @@ public class TypeVisitor extends PsiTypeVisitor { { for (PsiTypeParameter p : ((PsiClass) resolve).getTypeParameters()) { Type boundType = p.getSuperTypes().length > 0 ? - new ClassType(new IdentifierImpl(getClassTypeName(p.getSuperTypes()[0])), typesToTypeList(p.getSuperTypes()[0].getParameters()), true) + new ClassType(new IdentifierImpl(getClassTypeName(p.getSuperTypes()[0])), getConverter().typesToTypeList(p.getSuperTypes()[0].getParameters()), true) : new StarProjectionType(); @@ -163,10 +165,10 @@ public class TypeVisitor extends PsiTypeVisitor { @Override public Type visitWildcardType(@NotNull PsiWildcardType wildcardType) { if (wildcardType.isExtends()) { - myResult = new OutProjectionType(typeToType(wildcardType.getExtendsBound())); + myResult = new OutProjectionType(getConverter().typeToType(wildcardType.getExtendsBound())); } else if (wildcardType.isSuper()) { - myResult = new InProjectionType(typeToType(wildcardType.getSuperBound())); + myResult = new InProjectionType(getConverter().typeToType(wildcardType.getSuperBound())); } else { myResult = new StarProjectionType(); @@ -176,7 +178,7 @@ public class TypeVisitor extends PsiTypeVisitor { @Override public Type visitEllipsisType(@NotNull PsiEllipsisType ellipsisType) { - myResult = new VarArg(typeToType(ellipsisType.getComponentType())); + myResult = new VarArg(getConverter().typeToType(ellipsisType.getComponentType())); return super.visitEllipsisType(ellipsisType); } @@ -189,5 +191,11 @@ public class TypeVisitor extends PsiTypeVisitor { public Type visitDisjunctionType(PsiDisjunctionType disjunctionType) { return super.visitDisjunctionType(disjunctionType); } + + @NotNull + @Override + public Converter getConverter() { + return myConverter; + } } diff --git a/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java b/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java index 711177b71d2..11ab915e021 100644 --- a/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java +++ b/j2k/tests/test/org/jetbrains/jet/j2k/StandaloneJavaToKotlinConverterTest.java @@ -31,6 +31,7 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { @Override protected void runTest() throws Throwable { + Converter converter = new Converter(); String javaPath = "j2k/tests/testData/" + getTestFilePath(); String kotlinPath = javaPath.replace(".jav", ".kt"); @@ -45,19 +46,19 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { String actual = ""; String parentFileName = javaFile.getParentFile().getName(); if (parentFileName.equals("expression")) { - actual = expressionToKotlin(javaCode); + actual = expressionToKotlin(converter, javaCode); } else if (parentFileName.equals("statement")) { - actual = statementToKotlin(javaCode); + actual = statementToKotlin(converter, javaCode); } else if (parentFileName.equals("method")) { - actual = methodToKotlin(javaCode); + actual = methodToKotlin(converter, javaCode); } else if (parentFileName.equals("class")) { - actual = fileToKotlin(javaCode); + actual = fileToKotlin(converter, javaCode); } else if (parentFileName.equals("file")) { - actual = fileToKotlin(javaCode); + actual = fileToKotlin(converter, javaCode); } else if (parentFileName.equals("comp")) actual = fileToFileWithCompatibilityImport(javaCode); @@ -88,6 +89,7 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { @NotNull public static Test suite() { TestSuite suite = new TestSuite(); +// suite.addTest(new StandaloneJavaToKotlinConverterTest("ast/class/file", "kt-639")); suite.addTest(TestCaseBuilder.suiteForDirectory("j2k/tests/testData", "/ast", new TestCaseBuilder.NamedTestFactory() { @NotNull @Override @@ -104,38 +106,38 @@ public class StandaloneJavaToKotlinConverterTest extends TestCase { } @NotNull - private String fileToKotlin(@NotNull String text) { - return generateKotlinCode(JavaToKotlinTranslator.createFile(myJavaCoreEnvironment, text)); + private String fileToKotlin(Converter converter, @NotNull String text) { + return generateKotlinCode(converter, JavaToKotlinTranslator.createFile(myJavaCoreEnvironment, text)); } @NotNull - private static String generateKotlinCode(@Nullable PsiFile file) { + private static String generateKotlinCode(@NotNull Converter converter, @Nullable PsiFile file) { if (file != null && file instanceof PsiJavaFile) { - JavaToKotlinTranslator.setClassIdentifiers(file); - return prettify(Converter.elementToKotlin(file)); + JavaToKotlinTranslator.setClassIdentifiers(converter, file); + return prettify(converter.elementToKotlin(file)); } return ""; } @NotNull - private String methodToKotlin(String text) throws IOException { - String result = fileToKotlin("final class C {" + text + "}") + private String methodToKotlin(Converter converter, String text) throws IOException { + String result = fileToKotlin(converter, "final class C {" + text + "}") .replaceAll("class C\\(\\) \\{", ""); result = result.substring(0, result.lastIndexOf("}")); return prettify(result); } @NotNull - private String statementToKotlin(String text) throws Exception { - String result = methodToKotlin("void main() {" + text + "}"); + private String statementToKotlin(Converter converter, String text) throws Exception { + String result = methodToKotlin(converter, "void main() {" + text + "}"); int pos = result.lastIndexOf("}"); result = result.substring(0, pos).replaceFirst("fun main\\(\\) : Unit \\{", ""); return prettify(result); } @NotNull - private String expressionToKotlin(String code) throws Exception { - String result = statementToKotlin("Object o =" + code + "}"); + private String expressionToKotlin(Converter converter, String code) throws Exception { + String result = statementToKotlin(converter, "Object o =" + code + "}"); result = result.replaceFirst("var o : Any\\? =", ""); return prettify(result); }