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.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<PsiFile> 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<VirtualFile> newFiles = performFiles(allJavaFilesNear);
final List<VirtualFile> newFiles = convertFiles(converter, allJavaFilesNear);
if (finalRemoveIt) {
deleteFiles(allJavaFilesNear);
}
idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinActionUtil.java
+6 -8
View File
@@ -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<VirtualFile> performFiles(List<PsiFile> allJavaFilesNear) {
static List<VirtualFile> convertFiles(final Converter converter, List<PsiFile> allJavaFilesNear) {
final List<VirtualFile> result = new LinkedList<VirtualFile>();
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();
j2k/src/org/jetbrains/jet/j2k/Converter.java
+70 -68
View File
@@ -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<String> NOT_NULL_ANNOTATIONS = new HashSet<String>() {
{
add("org.jetbrains.annotations.NotNull");
add("com.sun.istack.internal.NotNull");
add("javax.annotation.Nonnull");
}
};
public static final Set<String> NOT_NULL_ANNOTATIONS = ImmutableSet.of(
"org.jetbrains.annotations.NotNull",
"com.sun.istack.internal.NotNull",
"javax.annotation.Nonnull"
);
@NotNull
private static Set<String> ourClassIdentifiers = new HashSet<String>();
private Set<String> 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<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);
}
public static boolean hasFlag(@NotNull J2KConverterFlags flag) {
public boolean hasFlag(@NotNull J2KConverterFlags flag) {
return flags.contains(flag);
}
public static void setClassIdentifiers(@NotNull Set<String> identifiers) {
ourClassIdentifiers = identifiers;
public void setClassIdentifiers(@NotNull Set<String> identifiers) {
classIdentifiers = identifiers;
}
@NotNull
public static Set<String> getClassIdentifiers() {
return new HashSet<String>(ourClassIdentifiers);
public Set<String> 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.<String>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<String> additionalImports) {
private File fileToFile(PsiJavaFile javaFile, List<String> additionalImports) {
final PsiImportList importList = javaFile.getImportList();
List<Import> imports = importList == null
? Collections.<Import>emptyList()
@@ -127,19 +129,19 @@ public class Converter {
}
@NotNull
private static List<Class> classesToClassList(@NotNull PsiClass[] classes) {
private List<Class> classesToClassList(@NotNull PsiClass[] classes) {
List<Class> result = new LinkedList<Class>();
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<Member> getMembers(@NotNull PsiClass psiClass) {
private List<Member> getMembers(@NotNull PsiClass psiClass) {
List<Member> members = new LinkedList<Member>();
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<String> modifiers = modifiersListToModifiersSet(psiClass.getModifierList());
final List<Field> fields = fieldsToFieldList(psiClass.getFields(), psiClass);
final List<Element> typeParameters = elementsToElementList(psiClass.getTypeParameters());
@@ -285,16 +287,16 @@ public class Converter {
}
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()) {
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
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<Field> fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) {
private List<Field> fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) {
List<Field> result = new LinkedList<Field>();
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<String> 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<Parameter> result = new LinkedList<Parameter>();
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<Statement> statementsToStatementList(@NotNull PsiStatement[] statements) {
public List<Statement> statementsToStatementList(@NotNull PsiStatement[] statements) {
List<Statement> result = new LinkedList<Statement>();
for (PsiStatement t : statements) result.add(statementToStatement(t));
return result;
}
@NotNull
public static List<Statement> statementsToStatementList(@NotNull List<PsiStatement> statements) {
public List<Statement> statementsToStatementList(@NotNull List<PsiStatement> statements) {
List<Statement> result = new LinkedList<Statement>();
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<Expression> expressionsToExpressionList(@NotNull PsiExpression[] expressions) {
public List<Expression> expressionsToExpressionList(@NotNull PsiExpression[] expressions) {
List<Expression> result = new LinkedList<Expression>();
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<Element> elementsToElementList(@NotNull PsiElement[] elements) {
public List<Element> elementsToElementList(@NotNull PsiElement[] elements) {
List<Element> result = new LinkedList<Element>();
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<Type> typesToTypeList(@NotNull PsiType[] types) {
public List<Type> typesToTypeList(@NotNull PsiType[] types) {
List<Type> result = new LinkedList<Type>();
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<Type> typesToNotNullableTypeList(@NotNull PsiType[] types) {
private List<Type> typesToNotNullableTypeList(@NotNull PsiType[] types) {
List<Type> result = new LinkedList<Type>(typesToTypeList(types));
for (Type p : result) p.convertedToNotNull();
return result;
@@ -634,14 +636,14 @@ public class Converter {
}
@NotNull
public static List<Parameter> parametersToParameterList(@NotNull PsiParameter[] parameters) {
public List<Parameter> parametersToParameterList(@NotNull PsiParameter[] parameters) {
List<Parameter> result = new LinkedList<Parameter>();
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<String> createConversions(@NotNull PsiCallExpression expression) {
public List<String> createConversions(@NotNull PsiCallExpression expression) {
PsiExpressionList argumentList = expression.getArgumentList();
PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{};
List<String> conversions = new LinkedList<String>();
@@ -699,7 +701,7 @@ public class Converter {
}
@NotNull
public static List<String> createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) {
public List<String> createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) {
PsiExpression[] arguments = expression.getOperands();
int length = arguments.length;
List<String> conversions = new LinkedList<String>();
@@ -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)
j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java
+9 -7
View File
@@ -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 "";
}
j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java
+5 -3
View File
@@ -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<Member> members) {
super(new IdentifierImpl("anonClass"),
public AnonymousClass(Converter converter, List<Member> members) {
super(converter,
new IdentifierImpl("anonClass"),
Collections.<String>emptySet(),
Collections.<Element>emptyList(),
Collections.<Type>emptyList(),
Collections.<Expression>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> 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) {
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<Member> getMembers(List<Member> members) {
/*package*/ static List<Member> getMembers(List<Member> members, Converter converter) {
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) {
if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) {
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;
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<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) {
super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members));
super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter));
}
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;
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<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) {
super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members));
super(converter, name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members, converter));
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;
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() {
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 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<Type> types = typesToTypeList(reference.getTypeParameters());
final List<Type> 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())
);
}
}
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 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<Type> typeParameters = reference != null
? typesToTypeList(reference.getTypeParameters())
? getConverter().typesToTypeList(reference.getTypeParameters())
: Collections.<Type>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)
);
}
}
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
*/
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())));
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 {
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<Statement> forStatements = new LinkedList<Statement>();
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<CaseContainer> switchBodyToCases(@Nullable final PsiCodeBlock body) {
private List<CaseContainer> switchBodyToCases(@Nullable final PsiCodeBlock body) {
final List<List<PsiStatement>> cases = splitToCases(body);
final List<PsiStatement> 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<PsiStatement> slice = ls.subList(1, ls.size());
if (!containsBreak(slice)) {
List<Statement> statements = statementsToStatementList(slice);
List<Statement> 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<Statement>();
}
else {
result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice)));
result.add(new CaseContainer(pendingLabels, getConverter().statementsToStatementList(slice)));
pendingLabels = new LinkedList<Statement>();
}
}
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<CatchStatement> catches = new LinkedList<CatchStatement>();
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
);
j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java
+3 -2
View File
@@ -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<PsiMethod> myResolvedConstructors = new HashSet<PsiMethod>();
private final Set<PsiMethod> myResolvedConstructors = Sets.newLinkedHashSet();
@Override
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.List;
import static org.jetbrains.jet.j2k.Converter.typeToType;
import static org.jetbrains.jet.j2k.Converter.typesToTypeList;
/**
* @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_CHARACTER = "java.lang.Character";
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";
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<Type> {
@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<Type> {
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<Type> {
}
@NotNull
private static List<Type> createRawTypesForResolvedReference(@NotNull PsiClassType classType) {
private List<Type> createRawTypesForResolvedReference(@NotNull PsiClassType classType) {
final List<Type> typeParams = new LinkedList<Type>();
if (classType instanceof PsiClassReferenceType) {
final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference();
@@ -133,7 +135,7 @@ public class TypeVisitor extends PsiTypeVisitor<Type> {
{
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<Type> {
@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<Type> {
@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<Type> {
public Type visitDisjunctionType(PsiDisjunctionType 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
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);
}