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

Refactored most of the static state out

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