Reformat code to use 4 spaces indent
This commit is contained in:
Andrey Breslav
File diff suppressed because it is too large
Load Diff
@@ -16,101 +16,103 @@ import static org.jetbrains.jet.j2k.Converter.NOT_NULL_ANNOTATIONS;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ConverterUtil {
|
||||
private ConverterUtil() {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String createMainFunction(@NotNull PsiFile file) {
|
||||
List<Pair<String, PsiMethod>> classNamesWithMains = new LinkedList<Pair<String, PsiMethod>>();
|
||||
|
||||
for (PsiClass c : ((PsiJavaFile) file).getClasses()) {
|
||||
PsiMethod main = findMainMethod(c);
|
||||
if (main != null) {
|
||||
classNamesWithMains.add(new Pair<String, PsiMethod>(c.getName(), main));
|
||||
}
|
||||
}
|
||||
if (classNamesWithMains.size() > 0) {
|
||||
String className = classNamesWithMains.get(0).getFirst();
|
||||
return MessageFormat.format("fun main(args : Array<String?>?) = {0}.main(args)", className);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiMethod findMainMethod(@NotNull PsiClass aClass) {
|
||||
if (isMainClass(aClass)) {
|
||||
final PsiMethod[] mainMethods = aClass.findMethodsByName("main", false);
|
||||
return findMainMethod(mainMethods);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiMethod findMainMethod(@NotNull PsiMethod[] mainMethods) {
|
||||
for (PsiMethod mainMethod : mainMethods) {
|
||||
if (isMainMethod(mainMethod)) return mainMethod;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static boolean isMainClass(@NotNull PsiClass psiClass) {
|
||||
if (psiClass instanceof PsiAnonymousClass) return false;
|
||||
if (psiClass.isInterface()) return false;
|
||||
return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC);
|
||||
}
|
||||
|
||||
public static boolean isMainMethod(@Nullable PsiMethod method) {
|
||||
if (method == null || method.getContainingClass() == null) return false;
|
||||
if (PsiType.VOID != method.getReturnType()) return false;
|
||||
if (!method.hasModifierProperty(PsiModifier.STATIC)) return false;
|
||||
if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false;
|
||||
final PsiParameter[] parameters = method.getParameterList().getParameters();
|
||||
if (parameters.length != 1) return false;
|
||||
final PsiType type = parameters[0].getType();
|
||||
if (!(type instanceof PsiArrayType)) return false;
|
||||
final PsiType componentType = ((PsiArrayType) type).getComponentType();
|
||||
return componentType.equalsToText("java.lang.String");
|
||||
}
|
||||
|
||||
public static int countWritingAccesses(@Nullable PsiElement element, @Nullable PsiElement container) {
|
||||
int counter = 0;
|
||||
if (container != null) {
|
||||
ReferenceCollector visitor = new ReferenceCollector();
|
||||
container.accept(visitor);
|
||||
for (PsiReferenceExpression e : visitor.getCollectedReferences())
|
||||
if (e.isReferenceTo(element) && PsiUtil.isAccessedForWriting(e))
|
||||
counter++;
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
||||
static boolean isReadOnly(PsiElement element, PsiElement container) {
|
||||
return countWritingAccesses(element, container) == 0;
|
||||
}
|
||||
|
||||
public static boolean isAnnotatedAsNotNull(@Nullable PsiModifierList modifierList) {
|
||||
if (modifierList != null) {
|
||||
PsiAnnotation[] annotations = modifierList.getAnnotations();
|
||||
for (PsiAnnotation a : annotations) {
|
||||
String qualifiedName = a.getQualifiedName();
|
||||
if (qualifiedName != null && NOT_NULL_ANNOTATIONS.contains(qualifiedName))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static class ReferenceCollector extends JavaRecursiveElementVisitor {
|
||||
public List<PsiReferenceExpression> getCollectedReferences() {
|
||||
return myCollectedReferences;
|
||||
private ConverterUtil() {
|
||||
}
|
||||
|
||||
private List<PsiReferenceExpression> myCollectedReferences = new LinkedList<PsiReferenceExpression>();
|
||||
@NotNull
|
||||
public static String createMainFunction(@NotNull PsiFile file) {
|
||||
List<Pair<String, PsiMethod>> classNamesWithMains = new LinkedList<Pair<String, PsiMethod>>();
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
myCollectedReferences.add(expression);
|
||||
for (PsiClass c : ((PsiJavaFile) file).getClasses()) {
|
||||
PsiMethod main = findMainMethod(c);
|
||||
if (main != null) {
|
||||
classNamesWithMains.add(new Pair<String, PsiMethod>(c.getName(), main));
|
||||
}
|
||||
}
|
||||
if (classNamesWithMains.size() > 0) {
|
||||
String className = classNamesWithMains.get(0).getFirst();
|
||||
return MessageFormat.format("fun main(args : Array<String?>?) = {0}.main(args)", className);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiMethod findMainMethod(@NotNull PsiClass aClass) {
|
||||
if (isMainClass(aClass)) {
|
||||
final PsiMethod[] mainMethods = aClass.findMethodsByName("main", false);
|
||||
return findMainMethod(mainMethods);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiMethod findMainMethod(@NotNull PsiMethod[] mainMethods) {
|
||||
for (PsiMethod mainMethod : mainMethods) {
|
||||
if (isMainMethod(mainMethod)) return mainMethod;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static boolean isMainClass(@NotNull PsiClass psiClass) {
|
||||
if (psiClass instanceof PsiAnonymousClass) return false;
|
||||
if (psiClass.isInterface()) return false;
|
||||
return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC);
|
||||
}
|
||||
|
||||
public static boolean isMainMethod(@Nullable PsiMethod method) {
|
||||
if (method == null || method.getContainingClass() == null) return false;
|
||||
if (PsiType.VOID != method.getReturnType()) return false;
|
||||
if (!method.hasModifierProperty(PsiModifier.STATIC)) return false;
|
||||
if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false;
|
||||
final PsiParameter[] parameters = method.getParameterList().getParameters();
|
||||
if (parameters.length != 1) return false;
|
||||
final PsiType type = parameters[0].getType();
|
||||
if (!(type instanceof PsiArrayType)) return false;
|
||||
final PsiType componentType = ((PsiArrayType) type).getComponentType();
|
||||
return componentType.equalsToText("java.lang.String");
|
||||
}
|
||||
|
||||
public static int countWritingAccesses(@Nullable PsiElement element, @Nullable PsiElement container) {
|
||||
int counter = 0;
|
||||
if (container != null) {
|
||||
ReferenceCollector visitor = new ReferenceCollector();
|
||||
container.accept(visitor);
|
||||
for (PsiReferenceExpression e : visitor.getCollectedReferences())
|
||||
if (e.isReferenceTo(element) && PsiUtil.isAccessedForWriting(e)) {
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
||||
static boolean isReadOnly(PsiElement element, PsiElement container) {
|
||||
return countWritingAccesses(element, container) == 0;
|
||||
}
|
||||
|
||||
public static boolean isAnnotatedAsNotNull(@Nullable PsiModifierList modifierList) {
|
||||
if (modifierList != null) {
|
||||
PsiAnnotation[] annotations = modifierList.getAnnotations();
|
||||
for (PsiAnnotation a : annotations) {
|
||||
String qualifiedName = a.getQualifiedName();
|
||||
if (qualifiedName != null && NOT_NULL_ANNOTATIONS.contains(qualifiedName)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static class ReferenceCollector extends JavaRecursiveElementVisitor {
|
||||
public List<PsiReferenceExpression> getCollectedReferences() {
|
||||
return myCollectedReferences;
|
||||
}
|
||||
|
||||
private List<PsiReferenceExpression> myCollectedReferences = new LinkedList<PsiReferenceExpression>();
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
myCollectedReferences.add(expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,178 +38,185 @@ import java.net.URLClassLoader;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class JavaToKotlinTranslator {
|
||||
private JavaToKotlinTranslator() {
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiFile createFile(@NotNull String text) {
|
||||
JavaCoreEnvironment javaCoreEnvironment = setUpJavaCoreEnvironment();
|
||||
return PsiFileFactory.getInstance(javaCoreEnvironment.getProject()).createFileFromText(
|
||||
"test.java", JavaLanguage.INSTANCE, text
|
||||
);
|
||||
}
|
||||
|
||||
@Nullable
|
||||
static PsiFile createFile(@NotNull JavaCoreEnvironment javaCoreEnvironment, @NotNull String text) {
|
||||
return PsiFileFactory.getInstance(javaCoreEnvironment.getProject()).createFileFromText(
|
||||
"test.java", JavaLanguage.INSTANCE, text
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
static JavaCoreEnvironment setUpJavaCoreEnvironment() {
|
||||
JavaCoreEnvironment javaCoreEnvironment = new JavaCoreEnvironment(new Disposable() {
|
||||
@Override
|
||||
public void dispose() {
|
||||
}
|
||||
});
|
||||
|
||||
javaCoreEnvironment.addToClasspath(findRtJar());
|
||||
File annotations = findAnnotations();
|
||||
if (annotations != null && annotations.exists()) {
|
||||
javaCoreEnvironment.addToClasspath(annotations);
|
||||
}
|
||||
return javaCoreEnvironment;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
static String prettify(@Nullable String code) {
|
||||
if (code == null)
|
||||
return "";
|
||||
return code
|
||||
.trim()
|
||||
.replaceAll("\r\n", "\n")
|
||||
.replaceAll(" \n", "\n")
|
||||
.replaceAll("\n ", "\n")
|
||||
.replaceAll("\n+", "\n")
|
||||
.replaceAll(" +", " ")
|
||||
.trim()
|
||||
;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findRtJar() {
|
||||
String javaHome = System.getenv("JAVA_HOME");
|
||||
File rtJar;
|
||||
if (javaHome == null) {
|
||||
rtJar = findActiveRtJar(true);
|
||||
|
||||
if (rtJar == null) {
|
||||
throw new SetupJavaCoreEnvironmentException("JAVA_HOME environment variable needs to be defined");
|
||||
}
|
||||
} else {
|
||||
rtJar = findRtJar(javaHome);
|
||||
private JavaToKotlinTranslator() {
|
||||
}
|
||||
|
||||
if (rtJar == null || !rtJar.exists()) {
|
||||
rtJar = findActiveRtJar(true);
|
||||
|
||||
if ((rtJar == null || !rtJar.exists())) {
|
||||
throw new SetupJavaCoreEnvironmentException("No rt.jar found under JAVA_HOME=" + javaHome);
|
||||
}
|
||||
}
|
||||
return rtJar;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findRtJar(String javaHome) {
|
||||
File rtJar = new File(javaHome, "jre/lib/rt.jar");
|
||||
if (rtJar.exists()) {
|
||||
return rtJar;
|
||||
@Nullable
|
||||
private static PsiFile createFile(@NotNull String text) {
|
||||
JavaCoreEnvironment javaCoreEnvironment = setUpJavaCoreEnvironment();
|
||||
return PsiFileFactory.getInstance(javaCoreEnvironment.getProject()).createFileFromText(
|
||||
"test.java", JavaLanguage.INSTANCE, text
|
||||
);
|
||||
}
|
||||
|
||||
File classesJar = new File(new File(javaHome).getParentFile().getAbsolutePath(), "Classes/classes.jar");
|
||||
if (classesJar.exists()) {
|
||||
return classesJar;
|
||||
@Nullable
|
||||
static PsiFile createFile(@NotNull JavaCoreEnvironment javaCoreEnvironment, @NotNull String text) {
|
||||
return PsiFileFactory.getInstance(javaCoreEnvironment.getProject()).createFileFromText(
|
||||
"test.java", JavaLanguage.INSTANCE, text
|
||||
);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findAnnotations() {
|
||||
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
|
||||
if (systemClassLoader instanceof URLClassLoader) {
|
||||
URLClassLoader loader = (URLClassLoader) systemClassLoader;
|
||||
for (URL url : loader.getURLs())
|
||||
if ("file".equals(url.getProtocol()) && url.getFile().endsWith("/annotations.jar"))
|
||||
return new File(url.getFile());
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@NotNull
|
||||
static JavaCoreEnvironment setUpJavaCoreEnvironment() {
|
||||
JavaCoreEnvironment javaCoreEnvironment = new JavaCoreEnvironment(new Disposable() {
|
||||
@Override
|
||||
public void dispose() {
|
||||
}
|
||||
});
|
||||
|
||||
@Nullable
|
||||
private static File findActiveRtJar(boolean failOnError) {
|
||||
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
|
||||
if (systemClassLoader instanceof URLClassLoader) {
|
||||
URLClassLoader loader = (URLClassLoader) systemClassLoader;
|
||||
for (URL url : loader.getURLs()) {
|
||||
if ("file".equals(url.getProtocol())) {
|
||||
if (url.getFile().endsWith("/lib/rt.jar")) {
|
||||
return new File(url.getFile());
|
||||
}
|
||||
if (url.getFile().endsWith("/Classes/classes.jar")) {
|
||||
return new File(url.getFile()).getAbsoluteFile();
|
||||
}
|
||||
javaCoreEnvironment.addToClasspath(findRtJar());
|
||||
File annotations = findAnnotations();
|
||||
if (annotations != null && annotations.exists()) {
|
||||
javaCoreEnvironment.addToClasspath(annotations);
|
||||
}
|
||||
}
|
||||
if (failOnError) {
|
||||
throw new SetupJavaCoreEnvironmentException("Could not find rt.jar in system class loader: " + StringUtil.join(loader.getURLs(), new Function<URL, String>() {
|
||||
@NotNull
|
||||
@Override
|
||||
public String fun(@NotNull URL url) {
|
||||
return url.toString() + "\n";
|
||||
}
|
||||
}, ", "));
|
||||
}
|
||||
} else if (failOnError) {
|
||||
throw new SetupJavaCoreEnvironmentException("System class loader is not an URLClassLoader: " + systemClassLoader);
|
||||
return javaCoreEnvironment;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
static void setClassIdentifiers(@NotNull PsiElement psiFile) {
|
||||
ClassVisitor c = new ClassVisitor();
|
||||
psiFile.accept(c);
|
||||
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());
|
||||
@NotNull
|
||||
static String prettify(@Nullable String code) {
|
||||
if (code == null) {
|
||||
return "";
|
||||
}
|
||||
return code
|
||||
.trim()
|
||||
.replaceAll("\r\n", "\n")
|
||||
.replaceAll(" \n", "\n")
|
||||
.replaceAll("\n ", "\n")
|
||||
.replaceAll("\n+", "\n")
|
||||
.replaceAll(" +", " ")
|
||||
.trim()
|
||||
;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
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());
|
||||
}
|
||||
return "";
|
||||
}
|
||||
@Nullable
|
||||
private static File findRtJar() {
|
||||
String javaHome = System.getenv("JAVA_HOME");
|
||||
File rtJar;
|
||||
if (javaHome == null) {
|
||||
rtJar = findActiveRtJar(true);
|
||||
|
||||
public static void main(@NotNull String[] args) throws IOException {
|
||||
//noinspection UseOfSystemOutOrSystemErr
|
||||
final PrintStream out = System.out;
|
||||
if (args.length == 1) {
|
||||
String kotlinCode = "";
|
||||
try {
|
||||
kotlinCode = generateKotlinCode(args[0]);
|
||||
} catch (Exception e) {
|
||||
out.println("EXCEPTION: " + e.getMessage());
|
||||
}
|
||||
if (kotlinCode.isEmpty())
|
||||
out.println("EXCEPTION: generated code is empty.");
|
||||
else
|
||||
out.println(kotlinCode);
|
||||
} else {
|
||||
out.println("EXCEPTION: wrong number of arguments (should be 1).");
|
||||
if (rtJar == null) {
|
||||
throw new SetupJavaCoreEnvironmentException("JAVA_HOME environment variable needs to be defined");
|
||||
}
|
||||
}
|
||||
else {
|
||||
rtJar = findRtJar(javaHome);
|
||||
}
|
||||
|
||||
if (rtJar == null || !rtJar.exists()) {
|
||||
rtJar = findActiveRtJar(true);
|
||||
|
||||
if ((rtJar == null || !rtJar.exists())) {
|
||||
throw new SetupJavaCoreEnvironmentException("No rt.jar found under JAVA_HOME=" + javaHome);
|
||||
}
|
||||
}
|
||||
return rtJar;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findRtJar(String javaHome) {
|
||||
File rtJar = new File(javaHome, "jre/lib/rt.jar");
|
||||
if (rtJar.exists()) {
|
||||
return rtJar;
|
||||
}
|
||||
|
||||
File classesJar = new File(new File(javaHome).getParentFile().getAbsolutePath(), "Classes/classes.jar");
|
||||
if (classesJar.exists()) {
|
||||
return classesJar;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findAnnotations() {
|
||||
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
|
||||
if (systemClassLoader instanceof URLClassLoader) {
|
||||
URLClassLoader loader = (URLClassLoader) systemClassLoader;
|
||||
for (URL url : loader.getURLs())
|
||||
if ("file".equals(url.getProtocol()) && url.getFile().endsWith("/annotations.jar")) {
|
||||
return new File(url.getFile());
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static File findActiveRtJar(boolean failOnError) {
|
||||
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
|
||||
if (systemClassLoader instanceof URLClassLoader) {
|
||||
URLClassLoader loader = (URLClassLoader) systemClassLoader;
|
||||
for (URL url : loader.getURLs()) {
|
||||
if ("file".equals(url.getProtocol())) {
|
||||
if (url.getFile().endsWith("/lib/rt.jar")) {
|
||||
return new File(url.getFile());
|
||||
}
|
||||
if (url.getFile().endsWith("/Classes/classes.jar")) {
|
||||
return new File(url.getFile()).getAbsoluteFile();
|
||||
}
|
||||
}
|
||||
}
|
||||
if (failOnError) {
|
||||
throw new SetupJavaCoreEnvironmentException("Could not find rt.jar in system class loader: " + StringUtil.join(loader.getURLs(), new Function<URL, String>() {
|
||||
@NotNull
|
||||
@Override
|
||||
public String fun(@NotNull URL url) {
|
||||
return url.toString() + "\n";
|
||||
}
|
||||
}, ", "));
|
||||
}
|
||||
}
|
||||
else if (failOnError) {
|
||||
throw new SetupJavaCoreEnvironmentException("System class loader is not an URLClassLoader: " + systemClassLoader);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
static void setClassIdentifiers(@NotNull PsiElement psiFile) {
|
||||
ClassVisitor c = new ClassVisitor();
|
||||
psiFile.accept(c);
|
||||
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());
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
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());
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
public static void main(@NotNull String[] args) throws IOException {
|
||||
//noinspection UseOfSystemOutOrSystemErr
|
||||
final PrintStream out = System.out;
|
||||
if (args.length == 1) {
|
||||
String kotlinCode = "";
|
||||
try {
|
||||
kotlinCode = generateKotlinCode(args[0]);
|
||||
} catch (Exception e) {
|
||||
out.println("EXCEPTION: " + e.getMessage());
|
||||
}
|
||||
if (kotlinCode.isEmpty()) {
|
||||
out.println("EXCEPTION: generated code is empty.");
|
||||
}
|
||||
else {
|
||||
out.println(kotlinCode);
|
||||
}
|
||||
}
|
||||
else {
|
||||
out.println("EXCEPTION: wrong number of arguments (should be 1).");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,6 +4,6 @@ package org.jetbrains.jet.j2k;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SetupJavaCoreEnvironmentException extends RuntimeException {
|
||||
public SetupJavaCoreEnvironmentException(String s) {
|
||||
}
|
||||
public SetupJavaCoreEnvironmentException(String s) {
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,20 +9,20 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class AnonymousClass extends Class {
|
||||
public AnonymousClass(List<Member> members) {
|
||||
super(new IdentifierImpl("anonClass"),
|
||||
Collections.<String>emptySet(),
|
||||
Collections.<Element>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
Collections.<Expression>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
getMembers(members)
|
||||
);
|
||||
}
|
||||
public AnonymousClass(List<Member> members) {
|
||||
super(new IdentifierImpl("anonClass"),
|
||||
Collections.<String>emptySet(),
|
||||
Collections.<Element>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
Collections.<Expression>emptyList(),
|
||||
Collections.<Type>emptyList(),
|
||||
getMembers(members)
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return bodyToKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return bodyToKotlin();
|
||||
}
|
||||
}
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ArrayAccessExpression extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final Expression myIndex;
|
||||
private final Expression myExpression;
|
||||
private final Expression myIndex;
|
||||
|
||||
public ArrayAccessExpression(Expression expression, Expression index) {
|
||||
myExpression = expression;
|
||||
myIndex = index;
|
||||
}
|
||||
public ArrayAccessExpression(Expression expression, Expression index) {
|
||||
myExpression = expression;
|
||||
myIndex = index;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + "[" + myIndex.toKotlin() + "]";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + "[" + myIndex.toKotlin() + "]";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,62 +9,64 @@ import java.util.*;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ArrayInitializerExpression extends Expression {
|
||||
private final Type myType;
|
||||
private final List<Expression> myInitializers;
|
||||
private final Type myType;
|
||||
private final List<Expression> myInitializers;
|
||||
|
||||
public ArrayInitializerExpression(final Type type, List<Expression> initializers) {
|
||||
myType = type;
|
||||
myInitializers = initializers;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String createArrayFunction(@NotNull final Type type) {
|
||||
String sType = innerTypeStr(type);
|
||||
if (PRIMITIVE_TYPES.contains(sType))
|
||||
return sType + "Array"; // intArray
|
||||
return AstUtil.lowerFirstCharacter(type.convertedToNotNull().toKotlin()); // array<Foo?>
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String innerTypeStr(@NotNull final Type type) {
|
||||
return type.convertedToNotNull().toKotlin().replace("Array", "").toLowerCase();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String createInitializers(@NotNull final Type type, @NotNull final List<Expression> initializers) {
|
||||
List<String> arguments = new LinkedList<String>();
|
||||
for (Expression i : initializers)
|
||||
arguments.add(explicitConvertIfNeeded(type, i));
|
||||
return AstUtil.join(arguments, COMMA_WITH_SPACE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String explicitConvertIfNeeded(@NotNull final Type type, @NotNull final Expression i) {
|
||||
Set<String> doubleOrFloatTypes = new HashSet<String>(
|
||||
Arrays.asList("double", "float", "java.lang.double", "java.lang.float")
|
||||
);
|
||||
String afterReplace = innerTypeStr(type).replace(">", "").replace("<", "").replace("?", "");
|
||||
if (doubleOrFloatTypes.contains(afterReplace)) {
|
||||
if (i.getKind() == Kind.LITERAL) {
|
||||
if (i.toKotlin().contains("."))
|
||||
return i.toKotlin();
|
||||
return i.toKotlin() + DOT + ZERO;
|
||||
}
|
||||
return "(" + i.toKotlin() + ")" + getConversion(afterReplace);
|
||||
public ArrayInitializerExpression(final Type type, List<Expression> initializers) {
|
||||
myType = type;
|
||||
myInitializers = initializers;
|
||||
}
|
||||
return i.toKotlin();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getConversion(@NotNull final String afterReplace) {
|
||||
if (afterReplace.contains("double")) return DOT + "dbl";
|
||||
if (afterReplace.contains("float")) return DOT + "flt";
|
||||
return "";
|
||||
}
|
||||
@NotNull
|
||||
private static String createArrayFunction(@NotNull final Type type) {
|
||||
String sType = innerTypeStr(type);
|
||||
if (PRIMITIVE_TYPES.contains(sType)) {
|
||||
return sType + "Array"; // intArray
|
||||
}
|
||||
return AstUtil.lowerFirstCharacter(type.convertedToNotNull().toKotlin()); // array<Foo?>
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return createArrayFunction(myType) + "(" + createInitializers(myType, myInitializers) + ")";
|
||||
}
|
||||
@NotNull
|
||||
private static String innerTypeStr(@NotNull final Type type) {
|
||||
return type.convertedToNotNull().toKotlin().replace("Array", "").toLowerCase();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String createInitializers(@NotNull final Type type, @NotNull final List<Expression> initializers) {
|
||||
List<String> arguments = new LinkedList<String>();
|
||||
for (Expression i : initializers)
|
||||
arguments.add(explicitConvertIfNeeded(type, i));
|
||||
return AstUtil.join(arguments, COMMA_WITH_SPACE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String explicitConvertIfNeeded(@NotNull final Type type, @NotNull final Expression i) {
|
||||
Set<String> doubleOrFloatTypes = new HashSet<String>(
|
||||
Arrays.asList("double", "float", "java.lang.double", "java.lang.float")
|
||||
);
|
||||
String afterReplace = innerTypeStr(type).replace(">", "").replace("<", "").replace("?", "");
|
||||
if (doubleOrFloatTypes.contains(afterReplace)) {
|
||||
if (i.getKind() == Kind.LITERAL) {
|
||||
if (i.toKotlin().contains(".")) {
|
||||
return i.toKotlin();
|
||||
}
|
||||
return i.toKotlin() + DOT + ZERO;
|
||||
}
|
||||
return "(" + i.toKotlin() + ")" + getConversion(afterReplace);
|
||||
}
|
||||
return i.toKotlin();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getConversion(@NotNull final String afterReplace) {
|
||||
if (afterReplace.contains("double")) return DOT + "dbl";
|
||||
if (afterReplace.contains("float")) return DOT + "flt";
|
||||
return "";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return createArrayFunction(myType) + "(" + createInitializers(myType, myInitializers) + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,27 +6,28 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ArrayType extends Type {
|
||||
private final Type myType;
|
||||
private final Type myType;
|
||||
|
||||
public ArrayType(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
public ArrayType(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
|
||||
public Type getInnerType() {
|
||||
return myType;
|
||||
}
|
||||
public Type getInnerType() {
|
||||
return myType;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.ARRAY_TYPE;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.ARRAY_TYPE;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (PRIMITIVE_TYPES.contains(myType.toKotlin().toLowerCase()))
|
||||
return myType.toKotlin() + "Array" + isNullableStr(); // returns IntArray, BooleanArray, etc.
|
||||
return "Array" + "<" + myType.toKotlin() + ">" + isNullableStr();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (PRIMITIVE_TYPES.contains(myType.toKotlin().toLowerCase())) {
|
||||
return myType.toKotlin() + "Array" + isNullableStr(); // returns IntArray, BooleanArray, etc.
|
||||
}
|
||||
return "Array" + "<" + myType.toKotlin() + ">" + isNullableStr();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,45 +9,48 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ArrayWithoutInitializationExpression extends Expression {
|
||||
private final Type myType;
|
||||
private final List<Expression> myExpressions;
|
||||
private final Type myType;
|
||||
private final List<Expression> myExpressions;
|
||||
|
||||
public ArrayWithoutInitializationExpression(Type type, List<Expression> expressions) {
|
||||
myType = type;
|
||||
myExpressions = expressions;
|
||||
}
|
||||
public ArrayWithoutInitializationExpression(Type type, List<Expression> expressions) {
|
||||
myType = type;
|
||||
myExpressions = expressions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myType.getKind() == Kind.ARRAY_TYPE)
|
||||
return constructInnerType((ArrayType) myType, myExpressions);
|
||||
return getConstructorName(myType);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myType.getKind() == Kind.ARRAY_TYPE) {
|
||||
return constructInnerType((ArrayType) myType, myExpressions);
|
||||
}
|
||||
return getConstructorName(myType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String constructInnerType(@NotNull ArrayType hostType, @NotNull List<Expression> expressions) {
|
||||
if (expressions.size() == 1)
|
||||
return oneDim(hostType, expressions.get(0));
|
||||
Type innerType = hostType.getInnerType();
|
||||
if (expressions.size() > 1 && innerType.getKind() == Kind.ARRAY_TYPE)
|
||||
return oneDim(hostType, expressions.get(0), "{" + constructInnerType((ArrayType) innerType, expressions.subList(1, expressions.size())) + "}");
|
||||
return getConstructorName(hostType);
|
||||
}
|
||||
@NotNull
|
||||
private static String constructInnerType(@NotNull ArrayType hostType, @NotNull List<Expression> expressions) {
|
||||
if (expressions.size() == 1) {
|
||||
return oneDim(hostType, expressions.get(0));
|
||||
}
|
||||
Type innerType = hostType.getInnerType();
|
||||
if (expressions.size() > 1 && innerType.getKind() == Kind.ARRAY_TYPE) {
|
||||
return oneDim(hostType, expressions.get(0), "{" + constructInnerType((ArrayType) innerType, expressions.subList(1, expressions.size())) + "}");
|
||||
}
|
||||
return getConstructorName(hostType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String oneDim(@NotNull Type type, @NotNull Expression size) {
|
||||
return oneDim(type, size, EMPTY);
|
||||
}
|
||||
@NotNull
|
||||
private static String oneDim(@NotNull Type type, @NotNull Expression size) {
|
||||
return oneDim(type, size, EMPTY);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String oneDim(@NotNull Type type, @NotNull Expression size, @NotNull String init) {
|
||||
String commaWithInit = init.isEmpty() ? EMPTY : COMMA_WITH_SPACE + init;
|
||||
return getConstructorName(type) + "(" + size.toKotlin() + commaWithInit + ")";
|
||||
}
|
||||
@NotNull
|
||||
private static String oneDim(@NotNull Type type, @NotNull Expression size, @NotNull String init) {
|
||||
String commaWithInit = init.isEmpty() ? EMPTY : COMMA_WITH_SPACE + init;
|
||||
return getConstructorName(type) + "(" + size.toKotlin() + commaWithInit + ")";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getConstructorName(@NotNull Type type) {
|
||||
return AstUtil.replaceLastQuest(type.toKotlin());
|
||||
}
|
||||
@NotNull
|
||||
private static String getConstructorName(@NotNull Type type) {
|
||||
return AstUtil.replaceLastQuest(type.toKotlin());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,18 +6,18 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class AssertStatement extends Statement {
|
||||
private final Expression myCondition;
|
||||
private final Expression myDetail;
|
||||
private final Expression myCondition;
|
||||
private final Expression myDetail;
|
||||
|
||||
public AssertStatement(Expression condition, Expression detail) {
|
||||
myCondition = condition;
|
||||
myDetail = detail;
|
||||
}
|
||||
public AssertStatement(Expression condition, Expression detail) {
|
||||
myCondition = condition;
|
||||
myDetail = detail;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String detail = myDetail != Expression.EMPTY_EXPRESSION ? "(" + myDetail.toKotlin() + ")" : EMPTY;
|
||||
return "assert" + detail + SPACE + "{" + myCondition.toKotlin() + "}";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String detail = myDetail != Expression.EMPTY_EXPRESSION ? "(" + myDetail.toKotlin() + ")" : EMPTY;
|
||||
return "assert" + detail + SPACE + "{" + myCondition.toKotlin() + "}";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,33 +6,33 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class AssignmentExpression extends Expression {
|
||||
private final Expression myLeft;
|
||||
private final Expression myRight;
|
||||
private final String myOp;
|
||||
private final Expression myLeft;
|
||||
private final Expression myRight;
|
||||
private final String myOp;
|
||||
|
||||
public Expression getLeft() {
|
||||
return myLeft;
|
||||
}
|
||||
public Expression getLeft() {
|
||||
return myLeft;
|
||||
}
|
||||
|
||||
public Expression getRight() {
|
||||
return myRight;
|
||||
}
|
||||
public Expression getRight() {
|
||||
return myRight;
|
||||
}
|
||||
|
||||
public AssignmentExpression(Expression left, Expression right, String op) {
|
||||
myLeft = left;
|
||||
myRight = right;
|
||||
myOp = op;
|
||||
}
|
||||
public AssignmentExpression(Expression left, Expression right, String op) {
|
||||
myLeft = left;
|
||||
myRight = right;
|
||||
myOp = op;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myLeft.toKotlin() + SPACE + myOp + SPACE + myRight.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myLeft.toKotlin() + SPACE + myOp + SPACE + myRight.toKotlin();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.ASSIGNMENT_EXPRESSION;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.ASSIGNMENT_EXPRESSION;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,26 +10,26 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class BinaryExpression extends Expression {
|
||||
private final Expression myLeft;
|
||||
private final Expression myRight;
|
||||
private final String myOp;
|
||||
private final List<String> myConversions;
|
||||
private final Expression myLeft;
|
||||
private final Expression myRight;
|
||||
private final String myOp;
|
||||
private final List<String> myConversions;
|
||||
|
||||
public BinaryExpression(Expression left, Expression right, String op) {
|
||||
this(left, right, op, Arrays.asList("", ""));
|
||||
}
|
||||
public BinaryExpression(Expression left, Expression right, String op) {
|
||||
this(left, right, op, Arrays.asList("", ""));
|
||||
}
|
||||
|
||||
public BinaryExpression(Expression left, Expression right, String op, List<String> conversions) {
|
||||
myLeft = left;
|
||||
myRight = right;
|
||||
myOp = op;
|
||||
myConversions = conversions;
|
||||
}
|
||||
public BinaryExpression(Expression left, Expression right, String op, List<String> conversions) {
|
||||
myLeft = left;
|
||||
myRight = right;
|
||||
myOp = op;
|
||||
myConversions = conversions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(Arrays.asList(myLeft, myRight)), myConversions);
|
||||
return AstUtil.join(expressionsWithConversions, SPACE + myOp + SPACE);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(Arrays.asList(myLeft, myRight)), myConversions);
|
||||
return AstUtil.join(expressionsWithConversions, SPACE + myOp + SPACE);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,42 +10,43 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Block extends Statement {
|
||||
@NotNull
|
||||
public final static Block EMPTY_BLOCK = new Block();
|
||||
@NotNull
|
||||
public final static Block EMPTY_BLOCK = new Block();
|
||||
|
||||
private List<Statement> myStatements;
|
||||
private boolean myNotEmpty = false;
|
||||
private List<Statement> myStatements;
|
||||
private boolean myNotEmpty = false;
|
||||
|
||||
private Block() {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
}
|
||||
private Block() {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
}
|
||||
|
||||
public Block(List<Statement> statements) {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
myStatements = statements;
|
||||
}
|
||||
public Block(List<Statement> statements) {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
myStatements = statements;
|
||||
}
|
||||
|
||||
public Block(List<Statement> statements, boolean notEmpty) {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
myStatements = statements;
|
||||
myNotEmpty = notEmpty;
|
||||
}
|
||||
public Block(List<Statement> statements, boolean notEmpty) {
|
||||
myStatements = new LinkedList<Statement>();
|
||||
myStatements = statements;
|
||||
myNotEmpty = notEmpty;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return !myNotEmpty && myStatements.size() == 0;
|
||||
}
|
||||
public boolean isEmpty() {
|
||||
return !myNotEmpty && myStatements.size() == 0;
|
||||
}
|
||||
|
||||
public List<Statement> getStatements() {
|
||||
return myStatements;
|
||||
}
|
||||
public List<Statement> getStatements() {
|
||||
return myStatements;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (!isEmpty())
|
||||
return "{" + N +
|
||||
AstUtil.joinNodes(myStatements, N) + N +
|
||||
"}";
|
||||
return EMPTY;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (!isEmpty()) {
|
||||
return "{" + N +
|
||||
AstUtil.joinNodes(myStatements, N) + N +
|
||||
"}";
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,26 +6,27 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class BreakStatement extends Statement {
|
||||
private Identifier myLabel = Identifier.EMPTY_IDENTIFIER;
|
||||
private Identifier myLabel = Identifier.EMPTY_IDENTIFIER;
|
||||
|
||||
public BreakStatement(Identifier label) {
|
||||
myLabel = label;
|
||||
}
|
||||
public BreakStatement(Identifier label) {
|
||||
myLabel = label;
|
||||
}
|
||||
|
||||
public BreakStatement() {
|
||||
}
|
||||
public BreakStatement() {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.BREAK;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.BREAK;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myLabel.isEmpty())
|
||||
return "break";
|
||||
return "break" + AT + myLabel.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myLabel.isEmpty()) {
|
||||
return "break";
|
||||
}
|
||||
return "break" + AT + myLabel.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,37 +6,40 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class CallChainExpression extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final Expression myIdentifier;
|
||||
private final Expression myExpression;
|
||||
private final Expression myIdentifier;
|
||||
|
||||
public Expression getIdentifier() {
|
||||
return myIdentifier;
|
||||
}
|
||||
public Expression getIdentifier() {
|
||||
return myIdentifier;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CALL_CHAIN;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CALL_CHAIN;
|
||||
}
|
||||
|
||||
public CallChainExpression(Expression expression, Expression identifier) {
|
||||
myExpression = expression;
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
public CallChainExpression(Expression expression, Expression identifier) {
|
||||
myExpression = expression;
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIdentifier.isNullable();
|
||||
}
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIdentifier.isNullable();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (!myExpression.isEmpty())
|
||||
if (myExpression.isNullable())
|
||||
return myExpression.toKotlin() + QUESTDOT + myIdentifier.toKotlin();
|
||||
else
|
||||
return myExpression.toKotlin() + DOT + myIdentifier.toKotlin();
|
||||
return myIdentifier.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (!myExpression.isEmpty()) {
|
||||
if (myExpression.isNullable()) {
|
||||
return myExpression.toKotlin() + QUESTDOT + myIdentifier.toKotlin();
|
||||
}
|
||||
else {
|
||||
return myExpression.toKotlin() + DOT + myIdentifier.toKotlin();
|
||||
}
|
||||
}
|
||||
return myIdentifier.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,21 +10,22 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class CaseContainer extends Statement {
|
||||
private final List<Statement> myCaseStatement;
|
||||
private final Block myBlock;
|
||||
private final List<Statement> myCaseStatement;
|
||||
private final Block myBlock;
|
||||
|
||||
public CaseContainer(final List<Statement> caseStatement, @NotNull final List<Statement> statements) {
|
||||
myCaseStatement = caseStatement;
|
||||
List<Statement> newStatements = new LinkedList<Statement>();
|
||||
for (Statement s : statements)
|
||||
if (s.getKind() != Kind.BREAK && s.getKind() != Kind.CONTINUE)
|
||||
newStatements.add(s);
|
||||
myBlock = new Block(newStatements);
|
||||
}
|
||||
public CaseContainer(final List<Statement> caseStatement, @NotNull final List<Statement> statements) {
|
||||
myCaseStatement = caseStatement;
|
||||
List<Statement> newStatements = new LinkedList<Statement>();
|
||||
for (Statement s : statements)
|
||||
if (s.getKind() != Kind.BREAK && s.getKind() != Kind.CONTINUE) {
|
||||
newStatements.add(s);
|
||||
}
|
||||
myBlock = new Block(newStatements);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myCaseStatement, COMMA_WITH_SPACE) + SPACE + "->" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myCaseStatement, COMMA_WITH_SPACE) + SPACE + "->" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class CatchStatement extends Statement {
|
||||
private final Parameter myVariable;
|
||||
private final Block myBlock;
|
||||
private final Parameter myVariable;
|
||||
private final Block myBlock;
|
||||
|
||||
public CatchStatement(Parameter variable, Block block) {
|
||||
myVariable = variable;
|
||||
myBlock = block;
|
||||
}
|
||||
public CatchStatement(Parameter variable, Block block) {
|
||||
myVariable = variable;
|
||||
myBlock = block;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "catch" + SPACE + "(" + myVariable.toKotlin() + ")" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "catch" + SPACE + "(" + myVariable.toKotlin() + ")" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,221 +16,237 @@ import static org.jetbrains.jet.j2k.util.AstUtil.*;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Class extends Member {
|
||||
@NotNull
|
||||
String TYPE = "class";
|
||||
final Identifier myName;
|
||||
private final List<Expression> myBaseClassParams;
|
||||
private final List<Member> myMembers;
|
||||
private final List<Element> myTypeParameters;
|
||||
private final List<Type> myExtendsTypes;
|
||||
private final List<Type> myImplementsTypes;
|
||||
@NotNull
|
||||
String TYPE = "class";
|
||||
final Identifier myName;
|
||||
private final List<Expression> myBaseClassParams;
|
||||
private final List<Member> myMembers;
|
||||
private final List<Element> myTypeParameters;
|
||||
private final List<Type> myExtendsTypes;
|
||||
private final List<Type> myImplementsTypes;
|
||||
|
||||
public Class(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
|
||||
List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> members) {
|
||||
myName = name;
|
||||
myBaseClassParams = baseClassParams;
|
||||
myModifiers = modifiers;
|
||||
myTypeParameters = typeParameters;
|
||||
myExtendsTypes = extendsTypes;
|
||||
myImplementsTypes = implementsTypes;
|
||||
myMembers= getMembers(members);
|
||||
}
|
||||
public Class(Identifier name, Set<String> modifiers, List<Element> typeParameters, List<Type> extendsTypes,
|
||||
List<Expression> baseClassParams, List<Type> implementsTypes, List<Member> members) {
|
||||
myName = name;
|
||||
myBaseClassParams = baseClassParams;
|
||||
myModifiers = modifiers;
|
||||
myTypeParameters = typeParameters;
|
||||
myExtendsTypes = extendsTypes;
|
||||
myImplementsTypes = implementsTypes;
|
||||
myMembers = getMembers(members);
|
||||
}
|
||||
|
||||
static List<Member> getMembers(List<Member> members) {
|
||||
List<Member> withoutPrivate = new LinkedList<Member>();
|
||||
if (Converter.hasSetting("public-only")) {
|
||||
for (Member m : members) {
|
||||
if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) {
|
||||
withoutPrivate.add(m);
|
||||
static List<Member> getMembers(List<Member> members) {
|
||||
List<Member> withoutPrivate = new LinkedList<Member>();
|
||||
if (Converter.hasSetting("public-only")) {
|
||||
for (Member m : members) {
|
||||
if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) {
|
||||
withoutPrivate.add(m);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
withoutPrivate = members;
|
||||
}
|
||||
return withoutPrivate;
|
||||
}
|
||||
|
||||
|
||||
@Nullable
|
||||
private Constructor getPrimaryConstructor() {
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() == Kind.CONSTRUCTOR)
|
||||
if (((Constructor) m).isPrimary())
|
||||
return (Constructor) m;
|
||||
return null;
|
||||
}
|
||||
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
Constructor maybeConstructor = getPrimaryConstructor();
|
||||
if (maybeConstructor != null)
|
||||
return maybeConstructor.primarySignatureToKotlin();
|
||||
return "(" + ")";
|
||||
}
|
||||
|
||||
String primaryConstructorBodyToKotlin() {
|
||||
Constructor maybeConstructor = getPrimaryConstructor();
|
||||
if (maybeConstructor != null && !maybeConstructor.getBlock().isEmpty())
|
||||
return maybeConstructor.primaryBodyToKotlin();
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
private boolean hasWhere() {
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter && ((TypeParameter) t).hasWhere())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String typeParameterWhereToKotlin() {
|
||||
if (hasWhere()) {
|
||||
List<String> wheres = new LinkedList<String>();
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter)
|
||||
wheres.add(((TypeParameter) t).getWhereToKotlin());
|
||||
return SPACE + "where" + SPACE + join(wheres, COMMA_WITH_SPACE) + SPACE;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
LinkedList<Member> membersExceptConstructors() {
|
||||
final LinkedList<Member> result = new LinkedList<Member>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() != Kind.CONSTRUCTOR)
|
||||
result.add(m);
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
List<Function> secondaryConstructorsAsStaticInitFunction() {
|
||||
final LinkedList<Function> result = new LinkedList<Function>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).isPrimary()) {
|
||||
Function f = (Function) m;
|
||||
Set<String> modifiers = new HashSet<String>(m.myModifiers);
|
||||
modifiers.add(Modifier.STATIC);
|
||||
|
||||
final List<Statement> statements = f.getBlock().getStatements();
|
||||
statements.add(new ReturnStatement(new IdentifierImpl("__"))); // TODO: move to one place, find other __ usages
|
||||
final Block block = new Block(statements);
|
||||
|
||||
final List<Element> typeParameters = new LinkedList<Element>();
|
||||
if (f.getTypeParameters().size() == 0)
|
||||
typeParameters.addAll(myTypeParameters);
|
||||
else {
|
||||
typeParameters.addAll(myTypeParameters);
|
||||
typeParameters.addAll(f.getTypeParameters());
|
||||
withoutPrivate = members;
|
||||
}
|
||||
return withoutPrivate;
|
||||
}
|
||||
|
||||
|
||||
@Nullable
|
||||
private Constructor getPrimaryConstructor() {
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() == Kind.CONSTRUCTOR) {
|
||||
if (((Constructor) m).isPrimary()) {
|
||||
return (Constructor) m;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
Constructor maybeConstructor = getPrimaryConstructor();
|
||||
if (maybeConstructor != null) {
|
||||
return maybeConstructor.primarySignatureToKotlin();
|
||||
}
|
||||
return "(" + ")";
|
||||
}
|
||||
|
||||
String primaryConstructorBodyToKotlin() {
|
||||
Constructor maybeConstructor = getPrimaryConstructor();
|
||||
if (maybeConstructor != null && !maybeConstructor.getBlock().isEmpty()) {
|
||||
return maybeConstructor.primaryBodyToKotlin();
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
private boolean hasWhere() {
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter && ((TypeParameter) t).hasWhere()) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String typeParameterWhereToKotlin() {
|
||||
if (hasWhere()) {
|
||||
List<String> wheres = new LinkedList<String>();
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter) {
|
||||
wheres.add(((TypeParameter) t).getWhereToKotlin());
|
||||
}
|
||||
return SPACE + "where" + SPACE + join(wheres, COMMA_WITH_SPACE) + SPACE;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
LinkedList<Member> membersExceptConstructors() {
|
||||
final LinkedList<Member> result = new LinkedList<Member>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() != Kind.CONSTRUCTOR) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
List<Function> secondaryConstructorsAsStaticInitFunction() {
|
||||
final LinkedList<Function> result = new LinkedList<Function>();
|
||||
for (Member m : myMembers)
|
||||
if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).isPrimary()) {
|
||||
Function f = (Function) m;
|
||||
Set<String> modifiers = new HashSet<String>(m.myModifiers);
|
||||
modifiers.add(Modifier.STATIC);
|
||||
|
||||
final List<Statement> statements = f.getBlock().getStatements();
|
||||
statements.add(new ReturnStatement(new IdentifierImpl("__"))); // TODO: move to one place, find other __ usages
|
||||
final Block block = new Block(statements);
|
||||
|
||||
final List<Element> typeParameters = new LinkedList<Element>();
|
||||
if (f.getTypeParameters().size() == 0) {
|
||||
typeParameters.addAll(myTypeParameters);
|
||||
}
|
||||
else {
|
||||
typeParameters.addAll(myTypeParameters);
|
||||
typeParameters.addAll(f.getTypeParameters());
|
||||
}
|
||||
|
||||
result.add(new Function(
|
||||
new IdentifierImpl("init"),
|
||||
modifiers,
|
||||
new ClassType(myName, typeParameters, false),
|
||||
typeParameters,
|
||||
f.getParams(),
|
||||
block
|
||||
));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String typeParametersToKotlin() {
|
||||
return myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
}
|
||||
|
||||
List<String> baseClassSignatureWithParams() {
|
||||
if (TYPE.equals("class") && myExtendsTypes.size() == 1) {
|
||||
LinkedList<String> result = new LinkedList<String>();
|
||||
result.add(myExtendsTypes.get(0).toKotlin() + "(" + joinNodes(myBaseClassParams, COMMA_WITH_SPACE) + ")");
|
||||
return result;
|
||||
}
|
||||
else {
|
||||
return nodesToKotlin(myExtendsTypes);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String implementTypesToKotlin() {
|
||||
List<String> allTypes = new LinkedList<String>() {
|
||||
{
|
||||
addAll(baseClassSignatureWithParams());
|
||||
addAll(nodesToKotlin(myImplementsTypes));
|
||||
}
|
||||
};
|
||||
return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
|
||||
if (needAbstractModifier()) {
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
}
|
||||
|
||||
result.add(new Function(
|
||||
new IdentifierImpl("init"),
|
||||
modifiers,
|
||||
new ClassType(myName, typeParameters, false),
|
||||
typeParameters,
|
||||
f.getParams(),
|
||||
block
|
||||
));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
modifierList.add(accessModifier());
|
||||
|
||||
@NotNull
|
||||
String typeParametersToKotlin() {
|
||||
return myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
}
|
||||
if (needOpenModifier()) {
|
||||
modifierList.add(Modifier.OPEN);
|
||||
}
|
||||
|
||||
List<String> baseClassSignatureWithParams() {
|
||||
if (TYPE.equals("class") && myExtendsTypes.size() == 1) {
|
||||
LinkedList<String> result = new LinkedList<String>();
|
||||
result.add(myExtendsTypes.get(0).toKotlin() + "(" + joinNodes(myBaseClassParams, COMMA_WITH_SPACE) + ")");
|
||||
return result;
|
||||
} else
|
||||
return nodesToKotlin(myExtendsTypes);
|
||||
}
|
||||
if (modifierList.size() > 0) {
|
||||
return join(modifierList, SPACE) + SPACE;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String implementTypesToKotlin() {
|
||||
List<String> allTypes = new LinkedList<String>() {
|
||||
{
|
||||
addAll(baseClassSignatureWithParams());
|
||||
addAll(nodesToKotlin(myImplementsTypes));
|
||||
}
|
||||
};
|
||||
return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
|
||||
if (needAbstractModifier())
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
|
||||
modifierList.add(accessModifier());
|
||||
|
||||
if (needOpenModifier())
|
||||
modifierList.add(Modifier.OPEN);
|
||||
|
||||
if (modifierList.size() > 0)
|
||||
return join(modifierList, SPACE) + SPACE;
|
||||
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
boolean needOpenModifier() {
|
||||
return !myModifiers.contains(Modifier.FINAL);
|
||||
}
|
||||
|
||||
boolean needAbstractModifier() {
|
||||
return isAbstract();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String bodyToKotlin() {
|
||||
return SPACE + "{" + N +
|
||||
AstUtil.joinNodes(getNonStatic(membersExceptConstructors()), N) + N +
|
||||
primaryConstructorBodyToKotlin() + N +
|
||||
classObjectToKotlin() + N +
|
||||
"}";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Member> getStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (m.isStatic())
|
||||
result.add(m);
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Member> getNonStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (!m.isStatic())
|
||||
result.add(m);
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private String classObjectToKotlin() {
|
||||
final List<Member> staticMembers = new LinkedList<Member>(secondaryConstructorsAsStaticInitFunction());
|
||||
staticMembers.addAll(getStatic(membersExceptConstructors()));
|
||||
if (staticMembers.size() > 0) {
|
||||
return "class" + SPACE + "object" + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(staticMembers, N) + N +
|
||||
"}";
|
||||
return EMPTY;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + TYPE + SPACE + myName.toKotlin() + typeParametersToKotlin() + primaryConstructorSignatureToKotlin() +
|
||||
implementTypesToKotlin() +
|
||||
typeParameterWhereToKotlin() +
|
||||
bodyToKotlin();
|
||||
}
|
||||
boolean needOpenModifier() {
|
||||
return !myModifiers.contains(Modifier.FINAL);
|
||||
}
|
||||
|
||||
boolean needAbstractModifier() {
|
||||
return isAbstract();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String bodyToKotlin() {
|
||||
return SPACE + "{" + N +
|
||||
AstUtil.joinNodes(getNonStatic(membersExceptConstructors()), N) + N +
|
||||
primaryConstructorBodyToKotlin() + N +
|
||||
classObjectToKotlin() + N +
|
||||
"}";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Member> getStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (m.isStatic()) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Member> getNonStatic(@NotNull List<? extends Member> members) {
|
||||
List<Member> result = new LinkedList<Member>();
|
||||
for (Member m : members)
|
||||
if (!m.isStatic()) {
|
||||
result.add(m);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private String classObjectToKotlin() {
|
||||
final List<Member> staticMembers = new LinkedList<Member>(secondaryConstructorsAsStaticInitFunction());
|
||||
staticMembers.addAll(getStatic(membersExceptConstructors()));
|
||||
if (staticMembers.size() > 0) {
|
||||
return "class" + SPACE + "object" + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(staticMembers, N) + N +
|
||||
"}";
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + TYPE + SPACE + myName.toKotlin() + typeParametersToKotlin() + primaryConstructorSignatureToKotlin() +
|
||||
implementTypesToKotlin() +
|
||||
typeParameterWhereToKotlin() +
|
||||
bodyToKotlin();
|
||||
}
|
||||
}
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ClassObjectAccessExpression extends Expression {
|
||||
private final Element myTypeElement;
|
||||
private final Element myTypeElement;
|
||||
|
||||
public ClassObjectAccessExpression(Element typeElement) {
|
||||
myTypeElement = typeElement;
|
||||
}
|
||||
public ClassObjectAccessExpression(Element typeElement) {
|
||||
myTypeElement = typeElement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "getJavaClass" + "<" + myTypeElement.toKotlin() + ">";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "getJavaClass" + "<" + myTypeElement.toKotlin() + ">";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,30 +10,32 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ClassType extends Type {
|
||||
private final Identifier myType;
|
||||
private final List<? extends Element> myParameters;
|
||||
private final Identifier myType;
|
||||
private final List<? extends Element> myParameters;
|
||||
|
||||
public ClassType(Identifier type, List<? extends Element> parameters, boolean nullable) {
|
||||
myType = type;
|
||||
myParameters = parameters;
|
||||
myNullable = nullable;
|
||||
}
|
||||
public ClassType(Identifier type, List<? extends Element> parameters, boolean nullable) {
|
||||
myType = type;
|
||||
myParameters = parameters;
|
||||
myNullable = nullable;
|
||||
}
|
||||
|
||||
public ClassType(Identifier type, List<? extends Element> parameters) {
|
||||
myType = type;
|
||||
myParameters = parameters;
|
||||
}
|
||||
public ClassType(Identifier type, List<? extends Element> parameters) {
|
||||
myType = type;
|
||||
myParameters = parameters;
|
||||
}
|
||||
|
||||
public ClassType(Identifier type) {
|
||||
myType = type;
|
||||
myNullable = false;
|
||||
myParameters = Collections.emptyList();
|
||||
}
|
||||
public ClassType(Identifier type) {
|
||||
myType = type;
|
||||
myNullable = false;
|
||||
myParameters = Collections.emptyList();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String params = myParameters.size() == 0 ? EMPTY : "<" + AstUtil.joinNodes(myParameters, COMMA_WITH_SPACE) + ">";
|
||||
return myType.toKotlin() + params + isNullableStr();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String params = myParameters.size() == 0
|
||||
? EMPTY
|
||||
: "<" + AstUtil.joinNodes(myParameters, COMMA_WITH_SPACE) + ">";
|
||||
return myType.toKotlin() + params + isNullableStr();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,30 +9,30 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Constructor extends Function {
|
||||
private final boolean myIsPrimary;
|
||||
private final boolean myIsPrimary;
|
||||
|
||||
public Constructor(Identifier identifier, Set<String> modifiers, Type type, List<Element> typeParameters, Element params, Block block, boolean isPrimary) {
|
||||
super(identifier, modifiers, type, typeParameters, params, block);
|
||||
myIsPrimary = isPrimary;
|
||||
}
|
||||
public Constructor(Identifier identifier, Set<String> modifiers, Type type, List<Element> typeParameters, Element params, Block block, boolean isPrimary) {
|
||||
super(identifier, modifiers, type, typeParameters, params, block);
|
||||
myIsPrimary = isPrimary;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String primarySignatureToKotlin() {
|
||||
return "(" + myParams.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
public String primarySignatureToKotlin() {
|
||||
return "(" + myParams.toKotlin() + ")";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String primaryBodyToKotlin() {
|
||||
return myBlock.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
public String primaryBodyToKotlin() {
|
||||
return myBlock.toKotlin();
|
||||
}
|
||||
|
||||
public boolean isPrimary() {
|
||||
return myIsPrimary;
|
||||
}
|
||||
public boolean isPrimary() {
|
||||
return myIsPrimary;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CONSTRUCTOR;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CONSTRUCTOR;
|
||||
}
|
||||
}
|
||||
@@ -6,26 +6,27 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ContinueStatement extends Statement {
|
||||
private Identifier myLabel = Identifier.EMPTY_IDENTIFIER;
|
||||
private Identifier myLabel = Identifier.EMPTY_IDENTIFIER;
|
||||
|
||||
public ContinueStatement(Identifier label) {
|
||||
myLabel = label;
|
||||
}
|
||||
public ContinueStatement(Identifier label) {
|
||||
myLabel = label;
|
||||
}
|
||||
|
||||
public ContinueStatement() {
|
||||
}
|
||||
public ContinueStatement() {
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CONTINUE;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.CONTINUE;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myLabel.isEmpty())
|
||||
return "continue";
|
||||
return "continue" + AT + myLabel.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myLabel.isEmpty()) {
|
||||
return "continue";
|
||||
}
|
||||
return "continue" + AT + myLabel.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,31 +10,31 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class DeclarationStatement extends Statement {
|
||||
private final List<Element> myElements;
|
||||
private final List<Element> myElements;
|
||||
|
||||
public DeclarationStatement(List<Element> elements) {
|
||||
myElements = elements;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<String> toStringList(@NotNull List<Element> elements) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
for (Element e : elements) {
|
||||
if (e instanceof LocalVariable) {
|
||||
LocalVariable v = (LocalVariable) e;
|
||||
|
||||
final String varKeyword = v.hasModifier(Modifier.FINAL) ? "val" : "var";
|
||||
result.add(
|
||||
varKeyword + SPACE + e.toKotlin()
|
||||
);
|
||||
}
|
||||
public DeclarationStatement(List<Element> elements) {
|
||||
myElements = elements;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.join(toStringList(myElements), N);
|
||||
}
|
||||
@NotNull
|
||||
private static List<String> toStringList(@NotNull List<Element> elements) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
for (Element e : elements) {
|
||||
if (e instanceof LocalVariable) {
|
||||
LocalVariable v = (LocalVariable) e;
|
||||
|
||||
final String varKeyword = v.hasModifier(Modifier.FINAL) ? "val" : "var";
|
||||
result.add(
|
||||
varKeyword + SPACE + e.toKotlin()
|
||||
);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.join(toStringList(myElements), N);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,9 +6,9 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class DefaultSwitchLabelStatement extends Statement {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "else";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "else";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class DoWhileStatement extends WhileStatement {
|
||||
public DoWhileStatement(Expression condition, Statement statement) {
|
||||
super(condition, statement);
|
||||
}
|
||||
public DoWhileStatement(Expression condition, Statement statement) {
|
||||
super(condition, statement);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "do" + N +
|
||||
myStatement.toKotlin() + N +
|
||||
"while" + SPACE + "(" + myCondition.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "do" + N +
|
||||
myStatement.toKotlin() + N +
|
||||
"while" + SPACE + "(" + myCondition.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
@@ -6,19 +6,19 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class DummyMethodCallExpression extends Expression {
|
||||
private final Element myWho;
|
||||
private final String myMethodName;
|
||||
private final Element myWhat;
|
||||
private final Element myWho;
|
||||
private final String myMethodName;
|
||||
private final Element myWhat;
|
||||
|
||||
public DummyMethodCallExpression(Element who, String methodName, Element what) {
|
||||
myWho = who;
|
||||
myMethodName = methodName;
|
||||
myWhat = what;
|
||||
}
|
||||
public DummyMethodCallExpression(Element who, String methodName, Element what) {
|
||||
myWho = who;
|
||||
myMethodName = methodName;
|
||||
myWhat = what;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myWho.toKotlin() + DOT + myMethodName + "(" + myWhat.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myWho.toKotlin() + DOT + myMethodName + "(" + myWhat.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class DummyStringExpression extends Expression {
|
||||
private final String myString;
|
||||
private final String myString;
|
||||
|
||||
public DummyStringExpression(String string) {
|
||||
myString = string;
|
||||
}
|
||||
public DummyStringExpression(String string) {
|
||||
myString = string;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myString;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myString;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,26 +6,26 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Element extends Node {
|
||||
@NotNull
|
||||
public static final Element EMPTY_ELEMENT = new EmptyElement();
|
||||
|
||||
public boolean isEmpty() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyElement extends Element {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
public static final Element EMPTY_ELEMENT = new EmptyElement();
|
||||
|
||||
public boolean isEmpty() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyElement extends Element {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,30 +10,30 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Enum extends Class {
|
||||
public Enum(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));
|
||||
}
|
||||
public Enum(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));
|
||||
}
|
||||
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
String s = super.primaryConstructorSignatureToKotlin();
|
||||
return s.equals("()") ? EMPTY : s;
|
||||
}
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
String s = super.primaryConstructorSignatureToKotlin();
|
||||
return s.equals("()") ? EMPTY : s;
|
||||
}
|
||||
|
||||
@Override
|
||||
boolean needOpenModifier() {
|
||||
return false;
|
||||
}
|
||||
@Override
|
||||
boolean needOpenModifier() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + "enum class" + SPACE + myName.toKotlin() + primaryConstructorSignatureToKotlin() +
|
||||
typeParametersToKotlin() + implementTypesToKotlin() + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(membersExceptConstructors(), N) + N +
|
||||
primaryConstructorBodyToKotlin() + N +
|
||||
"public fun name() : String { return \"\" }" + N + // TODO : remove hack
|
||||
"public fun order() : Int { return 0 }" + N +
|
||||
"}";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + "enum class" + SPACE + myName.toKotlin() + primaryConstructorSignatureToKotlin() +
|
||||
typeParametersToKotlin() + implementTypesToKotlin() + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(membersExceptConstructors(), N) + N +
|
||||
primaryConstructorBodyToKotlin() + N +
|
||||
"public fun name() : String { return \"\" }" + N + // TODO : remove hack
|
||||
"public fun order() : Int { return 0 }" + N +
|
||||
"}";
|
||||
}
|
||||
}
|
||||
@@ -8,15 +8,16 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class EnumConstant extends Field {
|
||||
public EnumConstant(Identifier identifier, Set<String> modifiers, @NotNull Type type, Element params) {
|
||||
super(identifier, modifiers, type.convertedToNotNull(), params, 0);
|
||||
}
|
||||
public EnumConstant(Identifier identifier, Set<String> modifiers, @NotNull Type type, Element params) {
|
||||
super(identifier, modifiers, type.convertedToNotNull(), params, 0);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myInitializer.toKotlin().isEmpty())
|
||||
return myIdentifier.toKotlin();
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin() + "(" + myInitializer.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myInitializer.toKotlin().isEmpty()) {
|
||||
return myIdentifier.toKotlin();
|
||||
}
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin() + "(" + myInitializer.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,26 +6,26 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Expression extends Statement {
|
||||
@NotNull
|
||||
public static final Expression EMPTY_EXPRESSION = new EmptyExpression();
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyExpression extends Expression {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
public static final Expression EMPTY_EXPRESSION = new EmptyExpression();
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyExpression extends Expression {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
boolean isNullable() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
boolean isNullable() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,19 +9,19 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ExpressionList extends Expression {
|
||||
private final List<Expression> myExpressions;
|
||||
private final List<Expression> myExpressions;
|
||||
|
||||
public ExpressionList(List<Expression> expressions, List<Type> types) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
public ExpressionList(List<Expression> expressions, List<Type> types) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
|
||||
public ExpressionList(List<Expression> expressions) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
public ExpressionList(List<Expression> expressions) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myExpressions, COMMA_WITH_SPACE);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myExpressions, COMMA_WITH_SPACE);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,15 +9,15 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ExpressionListStatement extends Expression {
|
||||
private final List<Expression> myExpressions;
|
||||
private final List<Expression> myExpressions;
|
||||
|
||||
public ExpressionListStatement(List<Expression> expressions) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
public ExpressionListStatement(List<Expression> expressions) {
|
||||
myExpressions = expressions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myExpressions, N);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myExpressions, N);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,65 +13,70 @@ import static org.jetbrains.jet.j2k.Converter.getDefaultInitializer;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Field extends Member {
|
||||
final Identifier myIdentifier;
|
||||
private final int myWritingAccesses;
|
||||
final Type myType;
|
||||
final Element myInitializer;
|
||||
final Identifier myIdentifier;
|
||||
private final int myWritingAccesses;
|
||||
final Type myType;
|
||||
final Element myInitializer;
|
||||
|
||||
public Field(Identifier identifier, Set<String> modifiers, Type type, Element initializer, int writingAccesses) {
|
||||
myIdentifier = identifier;
|
||||
myWritingAccesses = writingAccesses;
|
||||
myModifiers = modifiers;
|
||||
myType = type;
|
||||
myInitializer = initializer;
|
||||
}
|
||||
public Field(Identifier identifier, Set<String> modifiers, Type type, Element initializer, int writingAccesses) {
|
||||
myIdentifier = identifier;
|
||||
myWritingAccesses = writingAccesses;
|
||||
myModifiers = modifiers;
|
||||
myType = type;
|
||||
myInitializer = initializer;
|
||||
}
|
||||
|
||||
public Element getInitializer() {
|
||||
return myInitializer;
|
||||
}
|
||||
public Element getInitializer() {
|
||||
return myInitializer;
|
||||
}
|
||||
|
||||
public Identifier getIdentifier() {
|
||||
return myIdentifier;
|
||||
}
|
||||
public Identifier getIdentifier() {
|
||||
return myIdentifier;
|
||||
}
|
||||
|
||||
public Type getType() {
|
||||
return myType;
|
||||
}
|
||||
public Type getType() {
|
||||
return myType;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
@NotNull
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
|
||||
if (isAbstract())
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
if (isAbstract()) {
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
}
|
||||
|
||||
modifierList.add(accessModifier());
|
||||
modifierList.add(accessModifier());
|
||||
|
||||
modifierList.add(isVal() ? "val" : "var");
|
||||
modifierList.add(isVal() ? "val" : "var");
|
||||
|
||||
if (modifierList.size() > 0)
|
||||
return AstUtil.join(modifierList, SPACE) + SPACE;
|
||||
if (modifierList.size() > 0) {
|
||||
return AstUtil.join(modifierList, SPACE) + SPACE;
|
||||
}
|
||||
|
||||
return EMPTY;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
public boolean isVal() {
|
||||
return myModifiers.contains(Modifier.FINAL);
|
||||
}
|
||||
public boolean isVal() {
|
||||
return myModifiers.contains(Modifier.FINAL);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isStatic() {
|
||||
return myModifiers.contains(Modifier.STATIC);
|
||||
}
|
||||
@Override
|
||||
public boolean isStatic() {
|
||||
return myModifiers.contains(Modifier.STATIC);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String declaration = modifiersToKotlin() + myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String declaration = modifiersToKotlin() + myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
|
||||
if (myInitializer.isEmpty())
|
||||
return declaration + (isVal() && !isStatic() && myWritingAccesses == 1 ? EMPTY : SPACE + EQUAL + SPACE + getDefaultInitializer(this));
|
||||
if (myInitializer.isEmpty()) {
|
||||
return declaration + (isVal() && !isStatic() && myWritingAccesses == 1
|
||||
? EMPTY
|
||||
: SPACE + EQUAL + SPACE + getDefaultInitializer(this));
|
||||
}
|
||||
|
||||
return declaration + SPACE + EQUAL + SPACE + myInitializer.toKotlin();
|
||||
}
|
||||
return declaration + SPACE + EQUAL + SPACE + myInitializer.toKotlin();
|
||||
}
|
||||
}
|
||||
@@ -9,25 +9,26 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class File extends Node {
|
||||
private final String myPackageName;
|
||||
private final List<Import> myImports;
|
||||
private final List<Class> myClasses;
|
||||
private final String myMainFunction;
|
||||
private final String myPackageName;
|
||||
private final List<Import> myImports;
|
||||
private final List<Class> myClasses;
|
||||
private final String myMainFunction;
|
||||
|
||||
public File(String packageName, List<Import> imports, List<Class> classes, String mainFunction) {
|
||||
myPackageName = packageName;
|
||||
myImports = imports;
|
||||
myClasses = classes;
|
||||
myMainFunction = mainFunction;
|
||||
}
|
||||
public File(String packageName, List<Import> imports, List<Class> classes, String mainFunction) {
|
||||
myPackageName = packageName;
|
||||
myImports = imports;
|
||||
myClasses = classes;
|
||||
myMainFunction = mainFunction;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String common = AstUtil.joinNodes(myImports, N) + N2 + AstUtil.joinNodes(myClasses, N) + N + myMainFunction;
|
||||
if (myPackageName.isEmpty())
|
||||
return common;
|
||||
return "package" + SPACE + myPackageName + N +
|
||||
common;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String common = AstUtil.joinNodes(myImports, N) + N2 + AstUtil.joinNodes(myClasses, N) + N + myMainFunction;
|
||||
if (myPackageName.isEmpty()) {
|
||||
return common;
|
||||
}
|
||||
return "package" + SPACE + myPackageName + N +
|
||||
common;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,20 +6,20 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ForeachStatement extends Statement {
|
||||
private final Parameter myVariable;
|
||||
private final Expression myExpression;
|
||||
private final Statement myStatement;
|
||||
private final Parameter myVariable;
|
||||
private final Expression myExpression;
|
||||
private final Statement myStatement;
|
||||
|
||||
public ForeachStatement(Parameter variable, Expression expression, Statement statement) {
|
||||
myVariable = variable;
|
||||
myExpression = expression;
|
||||
myStatement = statement;
|
||||
}
|
||||
public ForeachStatement(Parameter variable, Expression expression, Statement statement) {
|
||||
myVariable = variable;
|
||||
myExpression = expression;
|
||||
myStatement = statement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "for" + SPACE + "(" + myVariable.toKotlin() + SPACE + IN + SPACE + myExpression.toKotlin() + ")" + N +
|
||||
myStatement.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "for" + SPACE + "(" + myVariable.toKotlin() + SPACE + IN + SPACE + myExpression.toKotlin() + ")" + N +
|
||||
myStatement.toKotlin();
|
||||
}
|
||||
}
|
||||
@@ -6,24 +6,24 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ForeachWithRangeStatement extends Statement {
|
||||
private final Expression myStart;
|
||||
private final IdentifierImpl myIdentifier;
|
||||
private final Expression myEnd;
|
||||
private final Statement myBody;
|
||||
private final Expression myStart;
|
||||
private final IdentifierImpl myIdentifier;
|
||||
private final Expression myEnd;
|
||||
private final Statement myBody;
|
||||
|
||||
public ForeachWithRangeStatement(IdentifierImpl identifier, Expression start, Expression end, Statement body) {
|
||||
myStart = start;
|
||||
myIdentifier = identifier;
|
||||
myEnd = end;
|
||||
myBody = body;
|
||||
}
|
||||
public ForeachWithRangeStatement(IdentifierImpl identifier, Expression start, Expression end, Statement body) {
|
||||
myStart = start;
|
||||
myIdentifier = identifier;
|
||||
myEnd = end;
|
||||
myBody = body;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "for" + SPACE + "(" +
|
||||
myIdentifier.toKotlin() + SPACE + "in" + SPACE + myStart.toKotlin() + ".." + myEnd.toKotlin() +
|
||||
")" + SPACE +
|
||||
myBody.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "for" + SPACE + "(" +
|
||||
myIdentifier.toKotlin() + SPACE + "in" + SPACE + myStart.toKotlin() + ".." + myEnd.toKotlin() +
|
||||
")" + SPACE +
|
||||
myBody.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,93 +11,101 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Function extends Member {
|
||||
private final Identifier myName;
|
||||
private final Type myType;
|
||||
private final List<Element> myTypeParameters;
|
||||
final Element myParams;
|
||||
private final Identifier myName;
|
||||
private final Type myType;
|
||||
private final List<Element> myTypeParameters;
|
||||
final Element myParams;
|
||||
|
||||
// TODO: maybe remove it?
|
||||
public void setBlock(Block block) {
|
||||
myBlock = block;
|
||||
}
|
||||
|
||||
Block myBlock;
|
||||
|
||||
public Function(Identifier name, Set<String> modifiers, Type type, List<Element> typeParameters, Element params, Block block) {
|
||||
myName = name;
|
||||
myModifiers = modifiers;
|
||||
myType = type;
|
||||
myTypeParameters = typeParameters;
|
||||
myParams = params;
|
||||
myBlock = block;
|
||||
}
|
||||
|
||||
public List<Element> getTypeParameters() {
|
||||
return myTypeParameters;
|
||||
}
|
||||
|
||||
public Element getParams() {
|
||||
return myParams;
|
||||
}
|
||||
|
||||
public Block getBlock() {
|
||||
return myBlock;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private String typeParametersToKotlin() {
|
||||
return myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
}
|
||||
|
||||
private boolean hasWhere() {
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter && ((TypeParameter) t).hasWhere())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
private String typeParameterWhereToKotlin() {
|
||||
if (hasWhere()) {
|
||||
List<String> wheres = new LinkedList<String>();
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter)
|
||||
wheres.add(((TypeParameter) t).getWhereToKotlin());
|
||||
return SPACE + "where" + SPACE + AstUtil.join(wheres, COMMA_WITH_SPACE) + SPACE;
|
||||
// TODO: maybe remove it?
|
||||
public void setBlock(Block block) {
|
||||
myBlock = block;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
Block myBlock;
|
||||
|
||||
if (isAbstract())
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
public Function(Identifier name, Set<String> modifiers, Type type, List<Element> typeParameters, Element params, Block block) {
|
||||
myName = name;
|
||||
myModifiers = modifiers;
|
||||
myType = type;
|
||||
myTypeParameters = typeParameters;
|
||||
myParams = params;
|
||||
myBlock = block;
|
||||
}
|
||||
|
||||
if (myModifiers.contains(Modifier.OVERRIDE))
|
||||
modifierList.add(Modifier.OVERRIDE);
|
||||
public List<Element> getTypeParameters() {
|
||||
return myTypeParameters;
|
||||
}
|
||||
|
||||
if (!myModifiers.contains(Modifier.OVERRIDE) && !myModifiers.contains(Modifier.FINAL))
|
||||
modifierList.add(Modifier.OPEN);
|
||||
public Element getParams() {
|
||||
return myParams;
|
||||
}
|
||||
|
||||
if (myModifiers.contains(Modifier.NOT_OPEN))
|
||||
modifierList.remove(Modifier.OPEN);
|
||||
public Block getBlock() {
|
||||
return myBlock;
|
||||
}
|
||||
|
||||
String accessModifier = accessModifier();
|
||||
if (!accessModifier.isEmpty())
|
||||
modifierList.add(accessModifier);
|
||||
@NotNull
|
||||
private String typeParametersToKotlin() {
|
||||
return myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
}
|
||||
|
||||
if (modifierList.size() > 0)
|
||||
return AstUtil.join(modifierList, SPACE) + SPACE;
|
||||
private boolean hasWhere() {
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter && ((TypeParameter) t).hasWhere()) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return EMPTY;
|
||||
}
|
||||
private String typeParameterWhereToKotlin() {
|
||||
if (hasWhere()) {
|
||||
List<String> wheres = new LinkedList<String>();
|
||||
for (Element t : myTypeParameters)
|
||||
if (t instanceof TypeParameter) {
|
||||
wheres.add(((TypeParameter) t).getWhereToKotlin());
|
||||
}
|
||||
return SPACE + "where" + SPACE + AstUtil.join(wheres, COMMA_WITH_SPACE) + SPACE;
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + "fun" + SPACE + myName.toKotlin() + typeParametersToKotlin() + "(" + myParams.toKotlin() + ")" + SPACE + COLON +
|
||||
SPACE + myType.toKotlin() + SPACE +
|
||||
typeParameterWhereToKotlin() +
|
||||
myBlock.toKotlin();
|
||||
}
|
||||
String modifiersToKotlin() {
|
||||
List<String> modifierList = new LinkedList<String>();
|
||||
|
||||
if (isAbstract()) {
|
||||
modifierList.add(Modifier.ABSTRACT);
|
||||
}
|
||||
|
||||
if (myModifiers.contains(Modifier.OVERRIDE)) {
|
||||
modifierList.add(Modifier.OVERRIDE);
|
||||
}
|
||||
|
||||
if (!myModifiers.contains(Modifier.OVERRIDE) && !myModifiers.contains(Modifier.FINAL)) {
|
||||
modifierList.add(Modifier.OPEN);
|
||||
}
|
||||
|
||||
if (myModifiers.contains(Modifier.NOT_OPEN)) {
|
||||
modifierList.remove(Modifier.OPEN);
|
||||
}
|
||||
|
||||
String accessModifier = accessModifier();
|
||||
if (!accessModifier.isEmpty()) {
|
||||
modifierList.add(accessModifier);
|
||||
}
|
||||
|
||||
if (modifierList.size() > 0) {
|
||||
return AstUtil.join(modifierList, SPACE) + SPACE;
|
||||
}
|
||||
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return modifiersToKotlin() + "fun" + SPACE + myName.toKotlin() + typeParametersToKotlin() + "(" + myParams.toKotlin() + ")" + SPACE + COLON +
|
||||
SPACE + myType.toKotlin() + SPACE +
|
||||
typeParameterWhereToKotlin() +
|
||||
myBlock.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,7 +4,7 @@ package org.jetbrains.jet.j2k.ast;
|
||||
* @author ignatov
|
||||
*/
|
||||
public interface IMember extends INode {
|
||||
boolean isStatic();
|
||||
boolean isStatic();
|
||||
|
||||
boolean isAbstract();
|
||||
boolean isAbstract();
|
||||
}
|
||||
|
||||
@@ -6,13 +6,13 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public interface INode {
|
||||
@NotNull
|
||||
String toKotlin();
|
||||
@NotNull
|
||||
String toKotlin();
|
||||
|
||||
@NotNull
|
||||
Kind getKind();
|
||||
@NotNull
|
||||
Kind getKind();
|
||||
|
||||
enum Kind {
|
||||
UNDEFINED, TYPE, CONSTRUCTOR, BREAK, CONTINUE, VARARG, TRAIT, ASSIGNMENT_EXPRESSION, CALL_CHAIN, LITERAL, ARRAY_TYPE,
|
||||
}
|
||||
enum Kind {
|
||||
UNDEFINED, TYPE, CONSTRUCTOR, BREAK, CONTINUE, VARARG, TRAIT, ASSIGNMENT_EXPRESSION, CALL_CHAIN, LITERAL, ARRAY_TYPE,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,10 +6,10 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public interface Identifier extends INode {
|
||||
@NotNull
|
||||
Identifier EMPTY_IDENTIFIER = new IdentifierImpl("");
|
||||
@NotNull
|
||||
Identifier EMPTY_IDENTIFIER = new IdentifierImpl("");
|
||||
|
||||
boolean isEmpty();
|
||||
boolean isEmpty();
|
||||
|
||||
String getName();
|
||||
String getName();
|
||||
}
|
||||
|
||||
@@ -6,54 +6,55 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class IdentifierImpl extends Expression implements Identifier {
|
||||
private final String myName;
|
||||
private boolean myIsNullable = true;
|
||||
private boolean myQuotingNeeded = true;
|
||||
private final String myName;
|
||||
private boolean myIsNullable = true;
|
||||
private boolean myQuotingNeeded = true;
|
||||
|
||||
public IdentifierImpl(String name) {
|
||||
myName = name;
|
||||
}
|
||||
public IdentifierImpl(String name) {
|
||||
myName = name;
|
||||
}
|
||||
|
||||
public IdentifierImpl(String name, boolean isNullable) {
|
||||
myName = name;
|
||||
myIsNullable = isNullable;
|
||||
}
|
||||
public IdentifierImpl(String name, boolean isNullable) {
|
||||
myName = name;
|
||||
myIsNullable = isNullable;
|
||||
}
|
||||
|
||||
public IdentifierImpl(String name, boolean isNullable, boolean quotingNeeded) {
|
||||
myName = name;
|
||||
myIsNullable = isNullable;
|
||||
myQuotingNeeded = quotingNeeded;
|
||||
}
|
||||
public IdentifierImpl(String name, boolean isNullable, boolean quotingNeeded) {
|
||||
myName = name;
|
||||
myIsNullable = isNullable;
|
||||
myQuotingNeeded = quotingNeeded;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return myName.length() == 0;
|
||||
}
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return myName.length() == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return myName;
|
||||
}
|
||||
@Override
|
||||
public String getName() {
|
||||
return myName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String quote(String str) {
|
||||
return BACKTICK + str + BACKTICK;
|
||||
}
|
||||
@NotNull
|
||||
private static String quote(String str) {
|
||||
return BACKTICK + str + BACKTICK;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIsNullable;
|
||||
}
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIsNullable;
|
||||
}
|
||||
|
||||
private String ifNeedQuote() {
|
||||
if (myQuotingNeeded && (ONLY_KOTLIN_KEYWORDS.contains(myName) || myName.contains("$")))
|
||||
return quote(myName);
|
||||
return myName;
|
||||
}
|
||||
private String ifNeedQuote() {
|
||||
if (myQuotingNeeded && (ONLY_KOTLIN_KEYWORDS.contains(myName) || myName.contains("$"))) {
|
||||
return quote(myName);
|
||||
}
|
||||
return myName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return ifNeedQuote();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return ifNeedQuote();
|
||||
}
|
||||
}
|
||||
@@ -6,26 +6,27 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class IfStatement extends Expression {
|
||||
private final Expression myCondition;
|
||||
private final Statement myThenStatement;
|
||||
private final Statement myElseStatement;
|
||||
private final Expression myCondition;
|
||||
private final Statement myThenStatement;
|
||||
private final Statement myElseStatement;
|
||||
|
||||
public IfStatement(Expression condition, Statement thenStatement, Statement elseStatement) {
|
||||
myCondition = condition;
|
||||
myThenStatement = thenStatement;
|
||||
myElseStatement = elseStatement;
|
||||
}
|
||||
public IfStatement(Expression condition, Statement thenStatement, Statement elseStatement) {
|
||||
myCondition = condition;
|
||||
myThenStatement = thenStatement;
|
||||
myElseStatement = elseStatement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String result = "if" + SPACE + "(" + myCondition.toKotlin() + ")" + N + myThenStatement.toKotlin() + N;
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String result = "if" + SPACE + "(" + myCondition.toKotlin() + ")" + N + myThenStatement.toKotlin() + N;
|
||||
|
||||
if (myElseStatement != Statement.EMPTY_STATEMENT)
|
||||
return result +
|
||||
"else" + N +
|
||||
myElseStatement.toKotlin();
|
||||
if (myElseStatement != Statement.EMPTY_STATEMENT) {
|
||||
return result +
|
||||
"else" + N +
|
||||
myElseStatement.toKotlin();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -6,19 +6,19 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Import extends Node {
|
||||
private final String myName;
|
||||
private final String myName;
|
||||
|
||||
public String getName() {
|
||||
return myName;
|
||||
}
|
||||
public String getName() {
|
||||
return myName;
|
||||
}
|
||||
|
||||
public Import(String name) {
|
||||
myName = name;
|
||||
}
|
||||
public Import(String name) {
|
||||
myName = name;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "import" + SPACE + myName;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "import" + SPACE + myName;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class InProjectionType extends Type {
|
||||
private final Type myBound;
|
||||
private final Type myBound;
|
||||
|
||||
public InProjectionType(Type bound) {
|
||||
myBound = bound;
|
||||
}
|
||||
public InProjectionType(Type bound) {
|
||||
myBound = bound;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "in" + SPACE + myBound.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "in" + SPACE + myBound.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,16 +8,16 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Initializer extends Member {
|
||||
private final Block myBlock;
|
||||
private final Block myBlock;
|
||||
|
||||
public Initializer(Block block, Set<String> modifiers) {
|
||||
myBlock = block;
|
||||
myModifiers = modifiers;
|
||||
}
|
||||
public Initializer(Block block, Set<String> modifiers) {
|
||||
myBlock = block;
|
||||
myModifiers = modifiers;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myBlock.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myBlock.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class IsOperator extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final Element myTypeElement;
|
||||
private final Expression myExpression;
|
||||
private final Element myTypeElement;
|
||||
|
||||
public IsOperator(Expression expression, Element typeElement) {
|
||||
myExpression = expression;
|
||||
myTypeElement = typeElement;
|
||||
}
|
||||
public IsOperator(Expression expression, Element typeElement) {
|
||||
myExpression = expression;
|
||||
myTypeElement = typeElement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + SPACE + "is" + SPACE + myTypeElement.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + SPACE + "is" + SPACE + myTypeElement.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class LabelStatement extends Statement {
|
||||
private final Identifier myName;
|
||||
private final Statement myStatement;
|
||||
private final Identifier myName;
|
||||
private final Statement myStatement;
|
||||
|
||||
public LabelStatement(Identifier name, Statement statement) {
|
||||
myName = name;
|
||||
myStatement = statement;
|
||||
}
|
||||
public LabelStatement(Identifier name, Statement statement) {
|
||||
myName = name;
|
||||
myStatement = statement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AT + myName.toKotlin() + SPACE + myStatement.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AT + myName.toKotlin() + SPACE + myStatement.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,21 +6,21 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class LiteralExpression extends Expression {
|
||||
private final Identifier myIdentifier;
|
||||
private final Identifier myIdentifier;
|
||||
|
||||
public LiteralExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
public LiteralExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.LITERAL;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.LITERAL;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myIdentifier.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myIdentifier.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,29 +8,30 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class LocalVariable extends Expression {
|
||||
private final Identifier myIdentifier;
|
||||
private final Set<String> myModifiersSet;
|
||||
private final Type myType;
|
||||
private final Expression myInitializer;
|
||||
private final Identifier myIdentifier;
|
||||
private final Set<String> myModifiersSet;
|
||||
private final Type myType;
|
||||
private final Expression myInitializer;
|
||||
|
||||
public LocalVariable(Identifier identifier, Set<String> modifiersSet, Type type, Expression initializer) {
|
||||
myIdentifier = identifier;
|
||||
myModifiersSet = modifiersSet;
|
||||
myType = type;
|
||||
myInitializer = initializer;
|
||||
}
|
||||
public LocalVariable(Identifier identifier, Set<String> modifiersSet, Type type, Expression initializer) {
|
||||
myIdentifier = identifier;
|
||||
myModifiersSet = modifiersSet;
|
||||
myType = type;
|
||||
myInitializer = initializer;
|
||||
}
|
||||
|
||||
public boolean hasModifier(String modifier) {
|
||||
return myModifiersSet.contains(modifier);
|
||||
}
|
||||
public boolean hasModifier(String modifier) {
|
||||
return myModifiersSet.contains(modifier);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myInitializer.isEmpty())
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myInitializer.isEmpty()) {
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
}
|
||||
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin() + SPACE +
|
||||
EQUAL + SPACE + myInitializer.toKotlin();
|
||||
}
|
||||
return myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin() + SPACE +
|
||||
EQUAL + SPACE + myInitializer.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,23 +8,24 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Member extends Node implements IMember {
|
||||
Set<String> myModifiers;
|
||||
Set<String> myModifiers;
|
||||
|
||||
@NotNull
|
||||
String accessModifier() {
|
||||
for (String m : myModifiers)
|
||||
if (m.equals(Modifier.PUBLIC) || m.equals(Modifier.PROTECTED) || m.equals(Modifier.PRIVATE))
|
||||
return m;
|
||||
return EMPTY; // package local converted to internal, but we use internal by default
|
||||
}
|
||||
@NotNull
|
||||
String accessModifier() {
|
||||
for (String m : myModifiers)
|
||||
if (m.equals(Modifier.PUBLIC) || m.equals(Modifier.PROTECTED) || m.equals(Modifier.PRIVATE)) {
|
||||
return m;
|
||||
}
|
||||
return EMPTY; // package local converted to internal, but we use internal by default
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isAbstract() {
|
||||
return myModifiers.contains(Modifier.ABSTRACT);
|
||||
}
|
||||
@Override
|
||||
public boolean isAbstract() {
|
||||
return myModifiers.contains(Modifier.ABSTRACT);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isStatic() {
|
||||
return myModifiers.contains(Modifier.STATIC);
|
||||
}
|
||||
@Override
|
||||
public boolean isStatic() {
|
||||
return myModifiers.contains(Modifier.STATIC);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,34 +9,36 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class MethodCallExpression extends Expression {
|
||||
private final Expression myMethodCall;
|
||||
private final List<Expression> myArguments;
|
||||
private final List<String> myConversions;
|
||||
private final boolean myIsResultNullable;
|
||||
private final List<Type> myTypeParameters;
|
||||
private final Expression myMethodCall;
|
||||
private final List<Expression> myArguments;
|
||||
private final List<String> myConversions;
|
||||
private final boolean myIsResultNullable;
|
||||
private final List<Type> myTypeParameters;
|
||||
|
||||
public MethodCallExpression(Expression methodCall, List<Expression> arguments, List<Type> typeParameters) {
|
||||
this(methodCall, arguments, AstUtil.createListWithEmptyString(arguments), false, typeParameters);
|
||||
}
|
||||
public MethodCallExpression(Expression methodCall, List<Expression> arguments, List<Type> typeParameters) {
|
||||
this(methodCall, arguments, AstUtil.createListWithEmptyString(arguments), false, typeParameters);
|
||||
}
|
||||
|
||||
public MethodCallExpression(Expression methodCall, List<Expression> arguments, List<String> conversions, boolean nullable, List<Type> typeParameters) {
|
||||
myMethodCall = methodCall;
|
||||
myArguments = arguments;
|
||||
myConversions = conversions;
|
||||
myIsResultNullable = nullable;
|
||||
myTypeParameters = typeParameters;
|
||||
}
|
||||
public MethodCallExpression(Expression methodCall, List<Expression> arguments, List<String> conversions, boolean nullable, List<Type> typeParameters) {
|
||||
myMethodCall = methodCall;
|
||||
myArguments = arguments;
|
||||
myConversions = conversions;
|
||||
myIsResultNullable = nullable;
|
||||
myTypeParameters = typeParameters;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIsResultNullable;
|
||||
}
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return myIsResultNullable;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String typeParamsToKotlin = myTypeParameters.size() > 0 ? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
List<String> applyConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myArguments), myConversions);
|
||||
return myMethodCall.toKotlin() + typeParamsToKotlin + "(" + AstUtil.join(applyConversions, COMMA_WITH_SPACE) + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String typeParamsToKotlin = myTypeParameters.size() > 0
|
||||
? "<" + AstUtil.joinNodes(myTypeParameters, COMMA_WITH_SPACE) + ">"
|
||||
: EMPTY;
|
||||
List<String> applyConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myArguments), myConversions);
|
||||
return myMethodCall.toKotlin() + typeParamsToKotlin + "(" + AstUtil.join(applyConversions, COMMA_WITH_SPACE) + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,24 +6,24 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Modifier {
|
||||
@NotNull
|
||||
public static final String PUBLIC = "public";
|
||||
@NotNull
|
||||
public static final String PROTECTED = "protected";
|
||||
@NotNull
|
||||
public static final String PRIVATE = "private";
|
||||
@NotNull
|
||||
public static final String INTERNAL = "internal";
|
||||
@NotNull
|
||||
public static final String STATIC = "static";
|
||||
@NotNull
|
||||
public static final String ABSTRACT = "abstract";
|
||||
@NotNull
|
||||
public static final String FINAL = "final";
|
||||
@NotNull
|
||||
public static final String OPEN = "open";
|
||||
@NotNull
|
||||
public static final String NOT_OPEN = "not open";
|
||||
@NotNull
|
||||
public static final String OVERRIDE = "override";
|
||||
@NotNull
|
||||
public static final String PUBLIC = "public";
|
||||
@NotNull
|
||||
public static final String PROTECTED = "protected";
|
||||
@NotNull
|
||||
public static final String PRIVATE = "private";
|
||||
@NotNull
|
||||
public static final String INTERNAL = "internal";
|
||||
@NotNull
|
||||
public static final String STATIC = "static";
|
||||
@NotNull
|
||||
public static final String ABSTRACT = "abstract";
|
||||
@NotNull
|
||||
public static final String FINAL = "final";
|
||||
@NotNull
|
||||
public static final String OPEN = "open";
|
||||
@NotNull
|
||||
public static final String NOT_OPEN = "not open";
|
||||
@NotNull
|
||||
public static final String OVERRIDE = "override";
|
||||
}
|
||||
|
||||
@@ -10,37 +10,38 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class NewClassExpression extends Expression {
|
||||
private final Element myName;
|
||||
private final List<Expression> myArguments;
|
||||
private Expression myQualifier;
|
||||
private List<String> myConversions;
|
||||
@Nullable
|
||||
private AnonymousClass myAnonymousClass = null;
|
||||
private final Element myName;
|
||||
private final List<Expression> myArguments;
|
||||
private Expression myQualifier;
|
||||
private List<String> myConversions;
|
||||
@Nullable
|
||||
private AnonymousClass myAnonymousClass = null;
|
||||
|
||||
private NewClassExpression(Element name, List<Expression> arguments) {
|
||||
myName = name;
|
||||
myQualifier = EMPTY_EXPRESSION;
|
||||
myArguments = arguments;
|
||||
myConversions = AstUtil.createListWithEmptyString(arguments);
|
||||
}
|
||||
private NewClassExpression(Element name, List<Expression> arguments) {
|
||||
myName = name;
|
||||
myQualifier = EMPTY_EXPRESSION;
|
||||
myArguments = arguments;
|
||||
myConversions = AstUtil.createListWithEmptyString(arguments);
|
||||
}
|
||||
|
||||
public NewClassExpression(@NotNull Expression qualifier, @NotNull Element name, @NotNull List<Expression> arguments,
|
||||
@NotNull List<String> conversions, @Nullable AnonymousClass anonymousClass) {
|
||||
this(name, arguments);
|
||||
myQualifier = qualifier;
|
||||
myConversions = conversions;
|
||||
myAnonymousClass = anonymousClass;
|
||||
}
|
||||
public NewClassExpression(@NotNull Expression qualifier, @NotNull Element name, @NotNull List<Expression> arguments,
|
||||
@NotNull List<String> conversions, @Nullable AnonymousClass anonymousClass) {
|
||||
this(name, arguments);
|
||||
myQualifier = qualifier;
|
||||
myConversions = conversions;
|
||||
myAnonymousClass = anonymousClass;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String callOperator = myQualifier.isNullable() ? QUESTDOT : DOT;
|
||||
final String qualifier = myQualifier.isEmpty() ? EMPTY : myQualifier.toKotlin() + callOperator;
|
||||
List<String> applyConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myArguments), myConversions);
|
||||
String appliedArguments = AstUtil.join(applyConversions, COMMA_WITH_SPACE);
|
||||
return myAnonymousClass != null ?
|
||||
"object" + SPACE + ":" + SPACE + qualifier + myName.toKotlin() + "(" + appliedArguments + ")" + myAnonymousClass.toKotlin() :
|
||||
qualifier + myName.toKotlin() + "(" + appliedArguments + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
final String callOperator = myQualifier.isNullable() ? QUESTDOT : DOT;
|
||||
final String qualifier = myQualifier.isEmpty() ? EMPTY : myQualifier.toKotlin() + callOperator;
|
||||
List<String> applyConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myArguments), myConversions);
|
||||
String appliedArguments = AstUtil.join(applyConversions, COMMA_WITH_SPACE);
|
||||
return myAnonymousClass != null ?
|
||||
"object" + SPACE + ":" + SPACE + qualifier + myName.toKotlin() + "(" + appliedArguments + ")" + myAnonymousClass.toKotlin()
|
||||
:
|
||||
qualifier + myName.toKotlin() + "(" + appliedArguments + ")";
|
||||
}
|
||||
}
|
||||
@@ -10,49 +10,49 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Node implements INode {
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.UNDEFINED;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.UNDEFINED;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
final static Set<String> ONLY_KOTLIN_KEYWORDS = new HashSet<String>(Arrays.asList(
|
||||
"package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This"
|
||||
));
|
||||
@NotNull
|
||||
final static Set<String> ONLY_KOTLIN_KEYWORDS = new HashSet<String>(Arrays.asList(
|
||||
"package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This"
|
||||
));
|
||||
|
||||
@NotNull
|
||||
public final static Set<String> PRIMITIVE_TYPES = new HashSet<String>(Arrays.asList(
|
||||
"double", "float", "long", "int", "short", "byte", "boolean", "char"
|
||||
));
|
||||
@NotNull
|
||||
public final static Set<String> PRIMITIVE_TYPES = new HashSet<String>(Arrays.asList(
|
||||
"double", "float", "long", "int", "short", "byte", "boolean", "char"
|
||||
));
|
||||
|
||||
static final String N = "\n";
|
||||
@NotNull
|
||||
static final String N2 = N + N;
|
||||
@NotNull
|
||||
static final String SPACE = " ";
|
||||
@NotNull
|
||||
static final String EQUAL = "=";
|
||||
@NotNull
|
||||
static final String EMPTY = "";
|
||||
@NotNull
|
||||
static final String DOT = ".";
|
||||
@NotNull
|
||||
static final String QUESTDOT = "?.";
|
||||
@NotNull
|
||||
static final String COLON = ":";
|
||||
@NotNull
|
||||
static final String IN = "in";
|
||||
@NotNull
|
||||
static final String AT = "@";
|
||||
@NotNull
|
||||
static final String BACKTICK = "`";
|
||||
@NotNull
|
||||
static final String QUEST = "?";
|
||||
@NotNull
|
||||
static final String COMMA_WITH_SPACE = "," + SPACE;
|
||||
@NotNull
|
||||
static final String STAR = "*";
|
||||
@NotNull
|
||||
protected static final String ZERO = "0";
|
||||
static final String N = "\n";
|
||||
@NotNull
|
||||
static final String N2 = N + N;
|
||||
@NotNull
|
||||
static final String SPACE = " ";
|
||||
@NotNull
|
||||
static final String EQUAL = "=";
|
||||
@NotNull
|
||||
static final String EMPTY = "";
|
||||
@NotNull
|
||||
static final String DOT = ".";
|
||||
@NotNull
|
||||
static final String QUESTDOT = "?.";
|
||||
@NotNull
|
||||
static final String COLON = ":";
|
||||
@NotNull
|
||||
static final String IN = "in";
|
||||
@NotNull
|
||||
static final String AT = "@";
|
||||
@NotNull
|
||||
static final String BACKTICK = "`";
|
||||
@NotNull
|
||||
static final String QUEST = "?";
|
||||
@NotNull
|
||||
static final String COMMA_WITH_SPACE = "," + SPACE;
|
||||
@NotNull
|
||||
static final String STAR = "*";
|
||||
@NotNull
|
||||
protected static final String ZERO = "0";
|
||||
}
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class OutProjectionType extends Type {
|
||||
private final Type myBound;
|
||||
private final Type myBound;
|
||||
|
||||
public OutProjectionType(Type bound) {
|
||||
myBound = bound;
|
||||
}
|
||||
public OutProjectionType(Type bound) {
|
||||
myBound = bound;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "out" + SPACE + myBound.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "out" + SPACE + myBound.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,26 +6,26 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Parameter extends Expression {
|
||||
private final Identifier myIdentifier;
|
||||
private final Type myType;
|
||||
private boolean myReadOnly;
|
||||
private final Identifier myIdentifier;
|
||||
private final Type myType;
|
||||
private boolean myReadOnly;
|
||||
|
||||
public Parameter(Identifier identifier, Type type) {
|
||||
myIdentifier = identifier;
|
||||
myType = type;
|
||||
myReadOnly = true;
|
||||
}
|
||||
public Parameter(Identifier identifier, Type type) {
|
||||
myIdentifier = identifier;
|
||||
myType = type;
|
||||
myReadOnly = true;
|
||||
}
|
||||
|
||||
public Parameter(IdentifierImpl identifier, Type type, boolean readOnly) {
|
||||
this(identifier, type);
|
||||
myReadOnly = readOnly;
|
||||
}
|
||||
public Parameter(IdentifierImpl identifier, Type type, boolean readOnly) {
|
||||
this(identifier, type);
|
||||
myReadOnly = readOnly;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String vararg = myType.getKind() == Kind.VARARG ? "vararg" + SPACE : EMPTY;
|
||||
String var = myReadOnly ? EMPTY : "var" + SPACE;
|
||||
return vararg + var + myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String vararg = myType.getKind() == Kind.VARARG ? "vararg" + SPACE : EMPTY;
|
||||
String var = myReadOnly ? EMPTY : "var" + SPACE;
|
||||
return vararg + var + myIdentifier.toKotlin() + SPACE + COLON + SPACE + myType.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,15 +9,15 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ParameterList extends Expression {
|
||||
private final List<Parameter> myParameters;
|
||||
private final List<Parameter> myParameters;
|
||||
|
||||
public ParameterList(List<Parameter> parameters) {
|
||||
myParameters = parameters;
|
||||
}
|
||||
public ParameterList(List<Parameter> parameters) {
|
||||
myParameters = parameters;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myParameters, COMMA_WITH_SPACE);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return AstUtil.joinNodes(myParameters, COMMA_WITH_SPACE);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ParenthesizedExpression extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final Expression myExpression;
|
||||
|
||||
public ParenthesizedExpression(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
public ParenthesizedExpression(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,21 +9,21 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class PolyadicExpression extends Expression {
|
||||
private final List<Expression> myExpressions;
|
||||
private final String myToken;
|
||||
private final List<String> myConversions;
|
||||
private final List<Expression> myExpressions;
|
||||
private final String myToken;
|
||||
private final List<String> myConversions;
|
||||
|
||||
public PolyadicExpression(List<Expression> expressions, String token, List<String> conversions) {
|
||||
super();
|
||||
myExpressions = expressions;
|
||||
myToken = token;
|
||||
myConversions = conversions;
|
||||
}
|
||||
public PolyadicExpression(List<Expression> expressions, String token, List<String> conversions) {
|
||||
super();
|
||||
myExpressions = expressions;
|
||||
myToken = token;
|
||||
myConversions = conversions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myExpressions), myConversions);
|
||||
return AstUtil.join(expressionsWithConversions, SPACE + myToken + SPACE);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
List<String> expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myExpressions), myConversions);
|
||||
return AstUtil.join(expressionsWithConversions, SPACE + myToken + SPACE);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class PostfixOperator extends Expression {
|
||||
private final String myOp;
|
||||
private final Expression myExpression;
|
||||
private final String myOp;
|
||||
private final Expression myExpression;
|
||||
|
||||
public PostfixOperator(String op, Expression expression) {
|
||||
myOp = op;
|
||||
myExpression = expression;
|
||||
}
|
||||
public PostfixOperator(String op, Expression expression) {
|
||||
myOp = op;
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + myOp;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + myOp;
|
||||
}
|
||||
}
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class PrefixOperator extends Expression {
|
||||
private final String myOp;
|
||||
private final Expression myExpression;
|
||||
private final String myOp;
|
||||
private final Expression myExpression;
|
||||
|
||||
public PrefixOperator(String op, Expression expression) {
|
||||
myOp = op;
|
||||
myExpression = expression;
|
||||
}
|
||||
public PrefixOperator(String op, Expression expression) {
|
||||
myOp = op;
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myOp + myExpression.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myOp + myExpression.toKotlin();
|
||||
}
|
||||
}
|
||||
@@ -6,20 +6,20 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class PrimitiveType extends Type {
|
||||
private final Identifier myType;
|
||||
private final Identifier myType;
|
||||
|
||||
public PrimitiveType(Identifier type) {
|
||||
myType = type;
|
||||
}
|
||||
public PrimitiveType(Identifier type) {
|
||||
myType = type;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return false;
|
||||
}
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,20 +9,20 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ReferenceElement extends Element {
|
||||
@NotNull
|
||||
private final Identifier myReference;
|
||||
@NotNull
|
||||
private final List<Type> myTypes;
|
||||
@NotNull
|
||||
private final Identifier myReference;
|
||||
@NotNull
|
||||
private final List<Type> myTypes;
|
||||
|
||||
public ReferenceElement(@NotNull Identifier reference, @NotNull List<Type> types) {
|
||||
myReference = reference;
|
||||
myTypes = types;
|
||||
}
|
||||
public ReferenceElement(@NotNull Identifier reference, @NotNull List<Type> types) {
|
||||
myReference = reference;
|
||||
myTypes = types;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String typesIfNeeded = myTypes.size() > 0 ? "<" + AstUtil.joinNodes(myTypes, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
return myReference.toKotlin() + typesIfNeeded;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
String typesIfNeeded = myTypes.size() > 0 ? "<" + AstUtil.joinNodes(myTypes, COMMA_WITH_SPACE) + ">" : EMPTY;
|
||||
return myReference.toKotlin() + typesIfNeeded;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,21 +7,21 @@ import org.jetbrains.jet.j2k.util.AstUtil;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ReturnStatement extends Statement {
|
||||
private final Expression myExpression;
|
||||
private String myConversion = EMPTY;
|
||||
private final Expression myExpression;
|
||||
private String myConversion = EMPTY;
|
||||
|
||||
public ReturnStatement(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
public ReturnStatement(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
public ReturnStatement(final Expression expression, final String conversion) {
|
||||
this(expression);
|
||||
myConversion = conversion;
|
||||
}
|
||||
public ReturnStatement(final Expression expression, final String conversion) {
|
||||
this(expression);
|
||||
myConversion = conversion;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "return" + SPACE + AstUtil.applyConversionForOneItem(myExpression.toKotlin(), myConversion);
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "return" + SPACE + AstUtil.applyConversionForOneItem(myExpression.toKotlin(), myConversion);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,16 +6,16 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class StarProjectionType extends Type {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
G g = new G("");
|
||||
G<String> g2 = new G<String>("");
|
||||
return STAR;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
G g = new G("");
|
||||
G<String> g2 = new G<String>("");
|
||||
return STAR;
|
||||
}
|
||||
}
|
||||
|
||||
class G <T extends String> {
|
||||
public <T> G(T t) {
|
||||
}
|
||||
class G<T extends String> {
|
||||
public <T> G(T t) {
|
||||
}
|
||||
}
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Statement extends Element {
|
||||
@NotNull
|
||||
public static final Statement EMPTY_STATEMENT = new EmptyStatement();
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyStatement extends Statement {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
public static final Statement EMPTY_STATEMENT = new EmptyStatement();
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyStatement extends Statement {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,18 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SuperExpression extends Expression {
|
||||
private final Identifier myIdentifier;
|
||||
private final Identifier myIdentifier;
|
||||
|
||||
public SuperExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
public SuperExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myIdentifier.isEmpty())
|
||||
return "super";
|
||||
return "super" + AT + myIdentifier.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myIdentifier.isEmpty()) {
|
||||
return "super";
|
||||
}
|
||||
return "super" + AT + myIdentifier.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,22 +6,22 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SureCallChainExpression extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final String myConversion;
|
||||
private final Expression myExpression;
|
||||
private final String myConversion;
|
||||
|
||||
public SureCallChainExpression(Expression expression, String conversion) {
|
||||
myExpression = expression;
|
||||
myConversion = conversion;
|
||||
}
|
||||
public SureCallChainExpression(Expression expression, String conversion) {
|
||||
myExpression = expression;
|
||||
myConversion = conversion;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return myExpression.isEmpty();
|
||||
}
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return myExpression.isEmpty();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + myConversion;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin() + myConversion;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,19 +9,19 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SwitchContainer extends Statement {
|
||||
private final Expression myExpression;
|
||||
private final List<CaseContainer> myCaseContainers;
|
||||
private final Expression myExpression;
|
||||
private final List<CaseContainer> myCaseContainers;
|
||||
|
||||
public SwitchContainer(final Expression expression, final List<CaseContainer> caseContainers) {
|
||||
myExpression = expression;
|
||||
myCaseContainers = caseContainers;
|
||||
}
|
||||
public SwitchContainer(final Expression expression, final List<CaseContainer> caseContainers) {
|
||||
myExpression = expression;
|
||||
myCaseContainers = caseContainers;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "when" + SPACE + "(" + myExpression.toKotlin() + ")" + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(myCaseContainers, N) + N +
|
||||
"}";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "when" + SPACE + "(" + myExpression.toKotlin() + ")" + SPACE + "{" + N +
|
||||
AstUtil.joinNodes(myCaseContainers, N) + N +
|
||||
"}";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SwitchLabelStatement extends Statement {
|
||||
private final Expression myExpression;
|
||||
private final Expression myExpression;
|
||||
|
||||
public SwitchLabelStatement(final Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
public SwitchLabelStatement(final Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myExpression.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SynchronizedStatement extends Statement {
|
||||
private final Expression myExpression;
|
||||
private final Block myBlock;
|
||||
private final Expression myExpression;
|
||||
private final Block myBlock;
|
||||
|
||||
public SynchronizedStatement(Expression expression, Block block) {
|
||||
myExpression = expression;
|
||||
myBlock = block;
|
||||
}
|
||||
public SynchronizedStatement(Expression expression, Block block) {
|
||||
myExpression = expression;
|
||||
myBlock = block;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "synchronized" + SPACE + "(" + myExpression.toKotlin() + ")" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "synchronized" + SPACE + "(" + myExpression.toKotlin() + ")" + SPACE + myBlock.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,18 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ThisExpression extends Expression {
|
||||
private final Identifier myIdentifier;
|
||||
private final Identifier myIdentifier;
|
||||
|
||||
public ThisExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
public ThisExpression(Identifier identifier) {
|
||||
myIdentifier = identifier;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myIdentifier.isEmpty())
|
||||
return "this";
|
||||
return "this" + AT + myIdentifier.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myIdentifier.isEmpty()) {
|
||||
return "this";
|
||||
}
|
||||
return "this" + AT + myIdentifier.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ThrowStatement extends Expression {
|
||||
private final Expression myExpression;
|
||||
private final Expression myExpression;
|
||||
|
||||
public ThrowStatement(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
public ThrowStatement(Expression expression) {
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "throw" + SPACE + myExpression.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "throw" + SPACE + myExpression.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,18 +7,18 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Trait extends Class {
|
||||
public Trait(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));
|
||||
TYPE = "trait";
|
||||
}
|
||||
public Trait(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));
|
||||
TYPE = "trait";
|
||||
}
|
||||
|
||||
@Override
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
@Override
|
||||
String primaryConstructorSignatureToKotlin() {
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
boolean needOpenModifier() {
|
||||
return false;
|
||||
}
|
||||
boolean needOpenModifier() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -9,22 +9,22 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class TryStatement extends Statement {
|
||||
private final Block myBlock;
|
||||
private final List<CatchStatement> myCatches;
|
||||
private final Block myFinallyBlock;
|
||||
private final Block myBlock;
|
||||
private final List<CatchStatement> myCatches;
|
||||
private final Block myFinallyBlock;
|
||||
|
||||
public TryStatement(Block block, List<CatchStatement> catches, Block finallyBlock) {
|
||||
myBlock = block;
|
||||
myCatches = catches;
|
||||
myFinallyBlock = finallyBlock;
|
||||
}
|
||||
public TryStatement(Block block, List<CatchStatement> catches, Block finallyBlock) {
|
||||
myBlock = block;
|
||||
myCatches = catches;
|
||||
myFinallyBlock = finallyBlock;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "try" + N +
|
||||
myBlock.toKotlin() + N +
|
||||
AstUtil.joinNodes(myCatches, N) + N +
|
||||
(myFinallyBlock.isEmpty() ? EMPTY : "finally" + N + myFinallyBlock.toKotlin());
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "try" + N +
|
||||
myBlock.toKotlin() + N +
|
||||
AstUtil.joinNodes(myCatches, N) + N +
|
||||
(myFinallyBlock.isEmpty() ? EMPTY : "finally" + N + myFinallyBlock.toKotlin());
|
||||
}
|
||||
}
|
||||
@@ -6,43 +6,43 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public abstract class Type extends Element {
|
||||
@NotNull
|
||||
public static final Type EMPTY_TYPE = new EmptyType();
|
||||
boolean myNullable = true;
|
||||
@NotNull
|
||||
public static final Type EMPTY_TYPE = new EmptyType();
|
||||
boolean myNullable = true;
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.TYPE;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public Type convertedToNotNull() {
|
||||
myNullable = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isNullable() {
|
||||
return myNullable;
|
||||
}
|
||||
|
||||
String isNullableStr() {
|
||||
return isNullable() ? QUEST : EMPTY;
|
||||
}
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyType extends Type {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "UNRESOLVED_TYPE";
|
||||
public Kind getKind() {
|
||||
return Kind.TYPE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return false;
|
||||
@NotNull
|
||||
public Type convertedToNotNull() {
|
||||
myNullable = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isNullable() {
|
||||
return myNullable;
|
||||
}
|
||||
|
||||
String isNullableStr() {
|
||||
return isNullable() ? QUEST : EMPTY;
|
||||
}
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
private static class EmptyType extends Type {
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "UNRESOLVED_TYPE";
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNullable() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,17 +6,17 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class TypeCastExpression extends Expression {
|
||||
private final Type myType;
|
||||
private final Expression myExpression;
|
||||
private final Type myType;
|
||||
private final Expression myExpression;
|
||||
|
||||
public TypeCastExpression(Type type, Expression expression) {
|
||||
myType = type;
|
||||
myExpression = expression;
|
||||
}
|
||||
public TypeCastExpression(Type type, Expression expression) {
|
||||
myType = type;
|
||||
myExpression = expression;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + SPACE + "as" + SPACE + myType.toKotlin() + ")";
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "(" + myExpression.toKotlin() + SPACE + "as" + SPACE + myType.toKotlin() + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,15 +6,15 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class TypeElement extends Element {
|
||||
private final Type myType;
|
||||
private final Type myType;
|
||||
|
||||
public TypeElement(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
public TypeElement(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,30 +8,32 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class TypeParameter extends Element {
|
||||
private final Identifier myName;
|
||||
private final List<Type> myExtendsTypes;
|
||||
private final Identifier myName;
|
||||
private final List<Type> myExtendsTypes;
|
||||
|
||||
public TypeParameter(Identifier name, List<Type> extendsTypes) {
|
||||
myName = name;
|
||||
myExtendsTypes = extendsTypes;
|
||||
}
|
||||
public TypeParameter(Identifier name, List<Type> extendsTypes) {
|
||||
myName = name;
|
||||
myExtendsTypes = extendsTypes;
|
||||
}
|
||||
|
||||
public boolean hasWhere() {
|
||||
return myExtendsTypes.size() > 1;
|
||||
}
|
||||
public boolean hasWhere() {
|
||||
return myExtendsTypes.size() > 1;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public String getWhereToKotlin() {
|
||||
if (hasWhere())
|
||||
return myName.toKotlin() + SPACE + COLON + SPACE + myExtendsTypes.get(1).toKotlin();
|
||||
return EMPTY;
|
||||
}
|
||||
@NotNull
|
||||
public String getWhereToKotlin() {
|
||||
if (hasWhere()) {
|
||||
return myName.toKotlin() + SPACE + COLON + SPACE + myExtendsTypes.get(1).toKotlin();
|
||||
}
|
||||
return EMPTY;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myExtendsTypes.size() > 0)
|
||||
return myName.toKotlin() + SPACE + COLON + SPACE + myExtendsTypes.get(0).toKotlin();
|
||||
return myName.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
if (myExtendsTypes.size() > 0) {
|
||||
return myName.toKotlin() + SPACE + COLON + SPACE + myExtendsTypes.get(0).toKotlin();
|
||||
}
|
||||
return myName.toKotlin();
|
||||
}
|
||||
}
|
||||
@@ -6,21 +6,21 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class VarArg extends Type {
|
||||
private final Type myType;
|
||||
private final Type myType;
|
||||
|
||||
public VarArg(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
public VarArg(Type type) {
|
||||
myType = type;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.VARARG;
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public Kind getKind() {
|
||||
return Kind.VARARG;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return myType.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,18 +6,18 @@ import org.jetbrains.annotations.NotNull;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class WhileStatement extends Statement {
|
||||
final Expression myCondition;
|
||||
final Statement myStatement;
|
||||
final Expression myCondition;
|
||||
final Statement myStatement;
|
||||
|
||||
public WhileStatement(Expression condition, Statement statement) {
|
||||
myCondition = condition;
|
||||
myStatement = statement;
|
||||
}
|
||||
public WhileStatement(Expression condition, Statement statement) {
|
||||
myCondition = condition;
|
||||
myStatement = statement;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "while" + SPACE + "(" + myCondition.toKotlin() + ")" + N +
|
||||
myStatement.toKotlin();
|
||||
}
|
||||
@NotNull
|
||||
@Override
|
||||
public String toKotlin() {
|
||||
return "while" + SPACE + "(" + myCondition.toKotlin() + ")" + N +
|
||||
myStatement.toKotlin();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,86 +12,91 @@ import java.util.Map;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class AstUtil {
|
||||
private AstUtil() {
|
||||
}
|
||||
|
||||
private static String join(@NotNull final String[] array, @Nullable final String delimiter) {
|
||||
StringBuilder buffer = new StringBuilder();
|
||||
boolean haveDelimiter = (delimiter != null);
|
||||
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
buffer.append(array[i]);
|
||||
|
||||
if (haveDelimiter && (i + 1) < array.length)
|
||||
buffer.append(delimiter);
|
||||
private AstUtil() {
|
||||
}
|
||||
|
||||
return buffer.toString();
|
||||
}
|
||||
private static String join(@NotNull final String[] array, @Nullable final String delimiter) {
|
||||
StringBuilder buffer = new StringBuilder();
|
||||
boolean haveDelimiter = (delimiter != null);
|
||||
|
||||
public static String joinNodes(@NotNull final List<? extends INode> nodes, final String delimiter) {
|
||||
return join(nodesToKotlin(nodes), delimiter);
|
||||
}
|
||||
for (int i = 0; i < array.length; i++) {
|
||||
buffer.append(array[i]);
|
||||
|
||||
public static String join(@NotNull final List<String> array, final String delimiter) {
|
||||
return join(array.toArray(new String[array.size()]), delimiter);
|
||||
}
|
||||
if (haveDelimiter && (i + 1) < array.length) {
|
||||
buffer.append(delimiter);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<String> nodesToKotlin(@NotNull List<? extends INode> nodes) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
for (INode n : nodes)
|
||||
result.add(n.toKotlin());
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String upperFirstCharacter(@NotNull String string) {
|
||||
return string.substring(0, 1).toUpperCase() + string.substring(1);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String lowerFirstCharacter(@NotNull String string) {
|
||||
return string.substring(0, 1).toLowerCase() + string.substring(1);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static <T> List<String> createListWithEmptyString(@NotNull final List<T> arguments) {
|
||||
final List<String> conversions = new LinkedList<String>();
|
||||
//noinspection UnusedDeclaration
|
||||
for (T argument : arguments) conversions.add("");
|
||||
return conversions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<String> applyConversions(@NotNull List<String> first, @NotNull List<String> second) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
assert first.size() == second.size() : "Lists must have the same size.";
|
||||
for (int i = 0; i < first.size(); i++) {
|
||||
result.add(applyConversionForOneItem(first.get(i), second.get(i)));
|
||||
return buffer.toString();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String applyConversionForOneItem(@NotNull String f, @NotNull String s) {
|
||||
if (s.isEmpty())
|
||||
return f;
|
||||
else
|
||||
return "(" + f + ")" + s;
|
||||
}
|
||||
public static String joinNodes(@NotNull final List<? extends INode> nodes, final String delimiter) {
|
||||
return join(nodesToKotlin(nodes), delimiter);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static <T> T getOrElse(@NotNull Map<T, T> map, @NotNull T e, @NotNull T orElse) {
|
||||
if (map.containsKey(e))
|
||||
return map.get(e);
|
||||
return orElse;
|
||||
}
|
||||
public static String join(@NotNull final List<String> array, final String delimiter) {
|
||||
return join(array.toArray(new String[array.size()]), delimiter);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String replaceLastQuest(@NotNull String str) {
|
||||
if (str.endsWith("?"))
|
||||
return str.substring(0, str.length() - 1);
|
||||
return str;
|
||||
}
|
||||
@NotNull
|
||||
public static List<String> nodesToKotlin(@NotNull List<? extends INode> nodes) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
for (INode n : nodes)
|
||||
result.add(n.toKotlin());
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String upperFirstCharacter(@NotNull String string) {
|
||||
return string.substring(0, 1).toUpperCase() + string.substring(1);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String lowerFirstCharacter(@NotNull String string) {
|
||||
return string.substring(0, 1).toLowerCase() + string.substring(1);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static <T> List<String> createListWithEmptyString(@NotNull final List<T> arguments) {
|
||||
final List<String> conversions = new LinkedList<String>();
|
||||
//noinspection UnusedDeclaration
|
||||
for (T argument : arguments) conversions.add("");
|
||||
return conversions;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static List<String> applyConversions(@NotNull List<String> first, @NotNull List<String> second) {
|
||||
List<String> result = new LinkedList<String>();
|
||||
assert first.size() == second.size() : "Lists must have the same size.";
|
||||
for (int i = 0; i < first.size(); i++) {
|
||||
result.add(applyConversionForOneItem(first.get(i), second.get(i)));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String applyConversionForOneItem(@NotNull String f, @NotNull String s) {
|
||||
if (s.isEmpty()) {
|
||||
return f;
|
||||
}
|
||||
else {
|
||||
return "(" + f + ")" + s;
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static <T> T getOrElse(@NotNull Map<T, T> map, @NotNull T e, @NotNull T orElse) {
|
||||
if (map.containsKey(e)) {
|
||||
return map.get(e);
|
||||
}
|
||||
return orElse;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String replaceLastQuest(@NotNull String str) {
|
||||
if (str.endsWith("?")) {
|
||||
return str.substring(0, str.length() - 1);
|
||||
}
|
||||
return str;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,20 +11,20 @@ import java.util.Set;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ClassVisitor extends JavaRecursiveElementVisitor {
|
||||
private final Set<String> myClassIdentifiers;
|
||||
private final Set<String> myClassIdentifiers;
|
||||
|
||||
public ClassVisitor() {
|
||||
myClassIdentifiers = new HashSet<String>();
|
||||
}
|
||||
public ClassVisitor() {
|
||||
myClassIdentifiers = new HashSet<String>();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public Set<String> getClassIdentifiers() {
|
||||
return new HashSet<String>(myClassIdentifiers);
|
||||
}
|
||||
@NotNull
|
||||
public Set<String> getClassIdentifiers() {
|
||||
return new HashSet<String>(myClassIdentifiers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitClass(@NotNull PsiClass aClass) {
|
||||
myClassIdentifiers.add(aClass.getQualifiedName());
|
||||
super.visitClass(aClass);
|
||||
}
|
||||
@Override
|
||||
public void visitClass(@NotNull PsiClass aClass) {
|
||||
myClassIdentifiers.add(aClass.getQualifiedName());
|
||||
super.visitClass(aClass);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,17 +4,17 @@ package org.jetbrains.jet.j2k.visitors;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class Dispatcher {
|
||||
private ExpressionVisitor myExpressionVisitor;
|
||||
private ExpressionVisitor myExpressionVisitor;
|
||||
|
||||
public void setExpressionVisitor(final ExpressionVisitor expressionVisitor) {
|
||||
this.myExpressionVisitor = expressionVisitor;
|
||||
}
|
||||
public void setExpressionVisitor(final ExpressionVisitor expressionVisitor) {
|
||||
this.myExpressionVisitor = expressionVisitor;
|
||||
}
|
||||
|
||||
public Dispatcher() {
|
||||
myExpressionVisitor = new ExpressionVisitor();
|
||||
}
|
||||
public Dispatcher() {
|
||||
myExpressionVisitor = new ExpressionVisitor();
|
||||
}
|
||||
|
||||
public ExpressionVisitor getExpressionVisitor() {
|
||||
return myExpressionVisitor;
|
||||
}
|
||||
public ExpressionVisitor getExpressionVisitor() {
|
||||
return myExpressionVisitor;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,86 +7,87 @@ import org.jetbrains.jet.j2k.ast.*;
|
||||
import java.util.List;
|
||||
|
||||
import static org.jetbrains.jet.j2k.Converter.*;
|
||||
import static org.jetbrains.jet.j2k.ConverterUtil.*;
|
||||
import static org.jetbrains.jet.j2k.ConverterUtil.isAnnotatedAsNotNull;
|
||||
|
||||
/**
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ElementVisitor extends JavaElementVisitor {
|
||||
@NotNull
|
||||
private Element myResult = Element.EMPTY_ELEMENT;
|
||||
@NotNull
|
||||
private Element myResult = Element.EMPTY_ELEMENT;
|
||||
|
||||
@NotNull
|
||||
public Element getResult() {
|
||||
return myResult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitLocalVariable(@NotNull PsiLocalVariable variable) {
|
||||
super.visitLocalVariable(variable);
|
||||
|
||||
myResult = new LocalVariable(
|
||||
new IdentifierImpl(variable.getName()), // TODO
|
||||
modifiersListToModifiersSet(variable.getModifierList()),
|
||||
typeToType(variable.getType(), isAnnotatedAsNotNull(variable.getModifierList())),
|
||||
createSureCallOnlyForChain(variable.getInitializer(), variable.getType())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionList(@NotNull PsiExpressionList list) {
|
||||
super.visitExpressionList(list);
|
||||
myResult = new ExpressionList(
|
||||
expressionsToExpressionList(list.getExpressions()),
|
||||
typesToTypeList(list.getExpressionTypes())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceElement(@NotNull PsiJavaCodeReferenceElement reference) {
|
||||
super.visitReferenceElement(reference);
|
||||
|
||||
final List<Type> types = typesToTypeList(reference.getTypeParameters());
|
||||
if (!reference.isQualified()) {
|
||||
myResult = new ReferenceElement(
|
||||
new IdentifierImpl(reference.getReferenceName()),
|
||||
types
|
||||
);
|
||||
} else {
|
||||
String result = new IdentifierImpl(reference.getReferenceName()).toKotlin();
|
||||
PsiElement qualifier = reference.getQualifier();
|
||||
while (qualifier != null) {
|
||||
final PsiJavaCodeReferenceElement p = (PsiJavaCodeReferenceElement) qualifier;
|
||||
result = new IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result; // TODO: maybe need to replace by safe call?
|
||||
qualifier = p.getQualifier();
|
||||
}
|
||||
myResult = new ReferenceElement(
|
||||
new IdentifierImpl(result),
|
||||
types
|
||||
);
|
||||
@NotNull
|
||||
public Element getResult() {
|
||||
return myResult;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypeElement(@NotNull PsiTypeElement type) {
|
||||
super.visitTypeElement(type);
|
||||
myResult = new TypeElement(typeToType(type.getType()));
|
||||
}
|
||||
@Override
|
||||
public void visitLocalVariable(@NotNull PsiLocalVariable variable) {
|
||||
super.visitLocalVariable(variable);
|
||||
|
||||
@Override
|
||||
public void visitTypeParameter(@NotNull PsiTypeParameter classParameter) {
|
||||
super.visitTypeParameter(classParameter);
|
||||
myResult = new TypeParameter(
|
||||
new IdentifierImpl(classParameter.getName()), // TODO
|
||||
typesToTypeList(classParameter.getExtendsListTypes())
|
||||
);
|
||||
}
|
||||
myResult = new LocalVariable(
|
||||
new IdentifierImpl(variable.getName()), // TODO
|
||||
modifiersListToModifiersSet(variable.getModifierList()),
|
||||
typeToType(variable.getType(), isAnnotatedAsNotNull(variable.getModifierList())),
|
||||
createSureCallOnlyForChain(variable.getInitializer(), variable.getType())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitParameterList(@NotNull PsiParameterList list) {
|
||||
super.visitParameterList(list);
|
||||
myResult = new ParameterList(
|
||||
parametersToParameterList(list.getParameters())
|
||||
);
|
||||
}
|
||||
@Override
|
||||
public void visitExpressionList(@NotNull PsiExpressionList list) {
|
||||
super.visitExpressionList(list);
|
||||
myResult = new ExpressionList(
|
||||
expressionsToExpressionList(list.getExpressions()),
|
||||
typesToTypeList(list.getExpressionTypes())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceElement(@NotNull PsiJavaCodeReferenceElement reference) {
|
||||
super.visitReferenceElement(reference);
|
||||
|
||||
final List<Type> types = typesToTypeList(reference.getTypeParameters());
|
||||
if (!reference.isQualified()) {
|
||||
myResult = new ReferenceElement(
|
||||
new IdentifierImpl(reference.getReferenceName()),
|
||||
types
|
||||
);
|
||||
}
|
||||
else {
|
||||
String result = new IdentifierImpl(reference.getReferenceName()).toKotlin();
|
||||
PsiElement qualifier = reference.getQualifier();
|
||||
while (qualifier != null) {
|
||||
final PsiJavaCodeReferenceElement p = (PsiJavaCodeReferenceElement) qualifier;
|
||||
result = new IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result; // TODO: maybe need to replace by safe call?
|
||||
qualifier = p.getQualifier();
|
||||
}
|
||||
myResult = new ReferenceElement(
|
||||
new IdentifierImpl(result),
|
||||
types
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypeElement(@NotNull PsiTypeElement type) {
|
||||
super.visitTypeElement(type);
|
||||
myResult = new TypeElement(typeToType(type.getType()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypeParameter(@NotNull PsiTypeParameter classParameter) {
|
||||
super.visitTypeParameter(classParameter);
|
||||
myResult = new TypeParameter(
|
||||
new IdentifierImpl(classParameter.getName()), // TODO
|
||||
typesToTypeList(classParameter.getExtendsListTypes())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitParameterList(@NotNull PsiParameterList list) {
|
||||
super.visitParameterList(list);
|
||||
myResult = new ParameterList(
|
||||
parametersToParameterList(list.getParameters())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -16,442 +16,469 @@ import static org.jetbrains.jet.j2k.visitors.TypeVisitor.*;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ExpressionVisitor extends StatementVisitor {
|
||||
@NotNull
|
||||
Expression myResult = Expression.EMPTY_EXPRESSION;
|
||||
@NotNull
|
||||
Expression myResult = Expression.EMPTY_EXPRESSION;
|
||||
|
||||
@Override
|
||||
public void visitExpression(final PsiExpression expression) {
|
||||
myResult = Expression.EMPTY_EXPRESSION;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Expression getResult() {
|
||||
return myResult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitArrayAccessExpression(@NotNull PsiArrayAccessExpression expression) {
|
||||
super.visitArrayAccessExpression(expression);
|
||||
myResult = new ArrayAccessExpression(
|
||||
expressionToExpression(expression.getArrayExpression()),
|
||||
expressionToExpression(expression.getIndexExpression())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitArrayInitializerExpression(@NotNull PsiArrayInitializerExpression expression) {
|
||||
super.visitArrayInitializerExpression(expression);
|
||||
myResult = new ArrayInitializerExpression(
|
||||
typeToType(expression.getType()),
|
||||
expressionsToExpressionList(expression.getInitializers())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression expression) {
|
||||
super.visitAssignmentExpression(expression);
|
||||
|
||||
// TODO: simplify
|
||||
|
||||
final IElementType tokenType = expression.getOperationSign().getTokenType();
|
||||
|
||||
String secondOp = "";
|
||||
if (tokenType == JavaTokenType.GTGTEQ) secondOp = "shr";
|
||||
if (tokenType == JavaTokenType.LTLTEQ) secondOp = "shl";
|
||||
if (tokenType == JavaTokenType.XOREQ) secondOp = "xor";
|
||||
if (tokenType == JavaTokenType.ANDEQ) secondOp = "and";
|
||||
if (tokenType == JavaTokenType.OREQ) secondOp = "or";
|
||||
if (tokenType == JavaTokenType.GTGTGTEQ) secondOp = "ushr";
|
||||
|
||||
if (!secondOp.isEmpty()) // if not Kotlin operators
|
||||
myResult = new AssignmentExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
new BinaryExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
expressionToExpression(expression.getRExpression()),
|
||||
secondOp
|
||||
),
|
||||
"="
|
||||
);
|
||||
else
|
||||
myResult = new AssignmentExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
expressionToExpression(expression.getRExpression()),
|
||||
expression.getOperationSign().getText() // TODO
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getOperatorString(@NotNull IElementType tokenType) {
|
||||
if (tokenType == JavaTokenType.PLUS) return "+";
|
||||
if (tokenType == JavaTokenType.MINUS) return "-";
|
||||
if (tokenType == JavaTokenType.ASTERISK) return "*";
|
||||
if (tokenType == JavaTokenType.DIV) return "/";
|
||||
if (tokenType == JavaTokenType.PERC) return "%";
|
||||
if (tokenType == JavaTokenType.GTGT) return "shr";
|
||||
if (tokenType == JavaTokenType.LTLT) return "shl";
|
||||
if (tokenType == JavaTokenType.XOR) return "xor";
|
||||
if (tokenType == JavaTokenType.AND) return "and";
|
||||
if (tokenType == JavaTokenType.OR) return "or";
|
||||
if (tokenType == JavaTokenType.GTGTGT) return "ushr";
|
||||
if (tokenType == JavaTokenType.GT) return ">";
|
||||
if (tokenType == JavaTokenType.LT) return "<";
|
||||
if (tokenType == JavaTokenType.GE) return ">=";
|
||||
if (tokenType == JavaTokenType.LE) return "<=";
|
||||
if (tokenType == JavaTokenType.EQEQ) return "==";
|
||||
if (tokenType == JavaTokenType.NE) return "!=";
|
||||
if (tokenType == JavaTokenType.ANDAND) return "&&";
|
||||
if (tokenType == JavaTokenType.OROR) return "||";
|
||||
if (tokenType == JavaTokenType.PLUSPLUS) return "++";
|
||||
if (tokenType == JavaTokenType.MINUSMINUS) return "--";
|
||||
if (tokenType == JavaTokenType.EXCL) return "!";
|
||||
|
||||
System.out.println("UNSUPPORTED TOKEN TYPE: " + tokenType.toString());
|
||||
return "";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBinaryExpression(@NotNull PsiBinaryExpression expression) {
|
||||
super.visitBinaryExpression(expression);
|
||||
|
||||
if (expression.getOperationSign().getTokenType() == JavaTokenType.GTGTGT)
|
||||
myResult = new DummyMethodCallExpression(
|
||||
expressionToExpression(expression.getLOperand()),
|
||||
"ushr",
|
||||
expressionToExpression(expression.getROperand()));
|
||||
else
|
||||
myResult =
|
||||
new BinaryExpression(
|
||||
expressionToExpression(expression.getLOperand()),
|
||||
expressionToExpression(expression.getROperand()),
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
createConversions(expression, PsiType.BOOLEAN)
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitClassObjectAccessExpression(@NotNull PsiClassObjectAccessExpression expression) {
|
||||
super.visitClassObjectAccessExpression(expression);
|
||||
myResult = new ClassObjectAccessExpression(elementToElement(expression.getOperand()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitConditionalExpression(@NotNull PsiConditionalExpression expression) {
|
||||
super.visitConditionalExpression(expression);
|
||||
PsiExpression condition = expression.getCondition();
|
||||
PsiType type = condition.getType();
|
||||
Expression e = type != null ?
|
||||
createSureCallOnlyForChain(condition, type) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new ParenthesizedExpression(
|
||||
new IfStatement(
|
||||
e,
|
||||
expressionToExpression(expression.getThenExpression()),
|
||||
expressionToExpression(expression.getElseExpression())
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionList(@NotNull PsiExpressionList list) {
|
||||
super.visitExpressionList(list);
|
||||
myResult = new ExpressionList(expressionsToExpressionList(list.getExpressions()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitInstanceOfExpression(@NotNull PsiInstanceOfExpression expression) {
|
||||
super.visitInstanceOfExpression(expression);
|
||||
myResult = new IsOperator(
|
||||
expressionToExpression(expression.getOperand()),
|
||||
elementToElement(expression.getCheckType()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitLiteralExpression(@NotNull PsiLiteralExpression expression) {
|
||||
super.visitLiteralExpression(expression);
|
||||
|
||||
final Object value = expression.getValue();
|
||||
String text = expression.getText();
|
||||
boolean isQuotingNeeded = true;
|
||||
|
||||
final PsiType type = expression.getType();
|
||||
if (type != null) {
|
||||
String canonicalTypeStr = type.getCanonicalText();
|
||||
if (canonicalTypeStr.equals("double") || canonicalTypeStr.equals(JAVA_LANG_DOUBLE))
|
||||
text = text.replace("D", "").replace("d", "");
|
||||
if (canonicalTypeStr.equals("float") || canonicalTypeStr.equals(JAVA_LANG_FLOAT))
|
||||
text = text.replace("F", "").replace("f", "") + "." + "flt";
|
||||
if (canonicalTypeStr.equals("long") || canonicalTypeStr.equals(JAVA_LANG_LONG))
|
||||
text = text.replace("L", "").replace("l", "");
|
||||
if (canonicalTypeStr.equals("int") || canonicalTypeStr.equals(JAVA_LANG_INTEGER)) // need for hex support
|
||||
text = value != null ? value.toString() : text;
|
||||
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_STRING))
|
||||
isQuotingNeeded = false;
|
||||
if (canonicalTypeStr.equals("char") || canonicalTypeStr.equals(JAVA_LANG_CHARACTER))
|
||||
isQuotingNeeded = false;
|
||||
@Override
|
||||
public void visitExpression(final PsiExpression expression) {
|
||||
myResult = Expression.EMPTY_EXPRESSION;
|
||||
}
|
||||
myResult = new LiteralExpression(new IdentifierImpl(text, false, isQuotingNeeded));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
|
||||
super.visitMethodCallExpression(expression);
|
||||
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())
|
||||
@NotNull
|
||||
@Override
|
||||
public Expression getResult() {
|
||||
return myResult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitArrayAccessExpression(@NotNull PsiArrayAccessExpression expression) {
|
||||
super.visitArrayAccessExpression(expression);
|
||||
myResult = new ArrayAccessExpression(
|
||||
expressionToExpression(expression.getArrayExpression()),
|
||||
expressionToExpression(expression.getIndexExpression())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitCallExpression(PsiCallExpression callExpression) {
|
||||
super.visitCallExpression(callExpression);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitNewExpression(@NotNull PsiNewExpression expression) {
|
||||
super.visitNewExpression(expression);
|
||||
if (expression.getArrayInitializer() != null) // new Foo[] {Foo(1), Foo(2)}
|
||||
myResult = createNewEmptyArray(expression);
|
||||
else if (expression.getArrayDimensions().length > 0) { // new Foo[5]
|
||||
myResult = createNewEmptyArrayWithoutInitialization(expression);
|
||||
} else { // new Class(): common case
|
||||
myResult = createNewClassExpression(expression);
|
||||
@Override
|
||||
public void visitArrayInitializerExpression(@NotNull PsiArrayInitializerExpression expression) {
|
||||
super.visitArrayInitializerExpression(expression);
|
||||
myResult = new ArrayInitializerExpression(
|
||||
typeToType(expression.getType()),
|
||||
expressionsToExpressionList(expression.getInitializers())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static 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());
|
||||
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
|
||||
);
|
||||
}
|
||||
// is constructor secondary
|
||||
final PsiJavaCodeReferenceElement reference = expression.getClassReference();
|
||||
final List<Type> typeParameters = reference != null ? typesToTypeList(reference.getTypeParameters()) : Collections.<Type>emptyList();
|
||||
return new CallChainExpression(
|
||||
new IdentifierImpl(constructor.getName(), false),
|
||||
new MethodCallExpression(
|
||||
new IdentifierImpl("init"),
|
||||
expressionsToExpressionList(arguments),
|
||||
typeParameters));
|
||||
}
|
||||
@Override
|
||||
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression expression) {
|
||||
super.visitAssignmentExpression(expression);
|
||||
|
||||
@NotNull
|
||||
private static Expression createNewEmptyArrayWithoutInitialization(@NotNull PsiNewExpression expression) {
|
||||
return new ArrayWithoutInitializationExpression(
|
||||
typeToType(expression.getType(), true),
|
||||
expressionsToExpressionList(expression.getArrayDimensions())
|
||||
);
|
||||
}
|
||||
// TODO: simplify
|
||||
|
||||
@NotNull
|
||||
private static Expression createNewEmptyArray(@NotNull PsiNewExpression expression) {
|
||||
return expressionToExpression(expression.getArrayInitializer());
|
||||
}
|
||||
final IElementType tokenType = expression.getOperationSign().getTokenType();
|
||||
|
||||
@Override
|
||||
public void visitParenthesizedExpression(@NotNull PsiParenthesizedExpression expression) {
|
||||
super.visitParenthesizedExpression(expression);
|
||||
myResult = new ParenthesizedExpression(
|
||||
expressionToExpression(expression.getExpression())
|
||||
);
|
||||
}
|
||||
String secondOp = "";
|
||||
if (tokenType == JavaTokenType.GTGTEQ) secondOp = "shr";
|
||||
if (tokenType == JavaTokenType.LTLTEQ) secondOp = "shl";
|
||||
if (tokenType == JavaTokenType.XOREQ) secondOp = "xor";
|
||||
if (tokenType == JavaTokenType.ANDEQ) secondOp = "and";
|
||||
if (tokenType == JavaTokenType.OREQ) secondOp = "or";
|
||||
if (tokenType == JavaTokenType.GTGTGTEQ) secondOp = "ushr";
|
||||
|
||||
@Override
|
||||
public void visitPostfixExpression(@NotNull PsiPostfixExpression expression) {
|
||||
super.visitPostfixExpression(expression);
|
||||
myResult = new PostfixOperator(
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPrefixExpression(@NotNull PsiPrefixExpression expression) {
|
||||
super.visitPrefixExpression(expression);
|
||||
if (expression.getOperationTokenType() == JavaTokenType.TILDE)
|
||||
myResult = new DummyMethodCallExpression(
|
||||
new ParenthesizedExpression(expressionToExpression(expression.getOperand())), "inv", Expression.EMPTY_EXPRESSION
|
||||
);
|
||||
else
|
||||
myResult = new PrefixOperator(
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
|
||||
final boolean isFieldReference = isFieldReference(expression, getContainingClass(expression));
|
||||
final boolean insideSecondaryConstructor = isInsideSecondaryConstructor(expression);
|
||||
final boolean hasReceiver = isFieldReference && insideSecondaryConstructor;
|
||||
final boolean isThis = isThisExpression(expression);
|
||||
final boolean isNullable = typeToType(expression.getType()).isNullable();
|
||||
final String className = getClassNameWithConstructor(expression);
|
||||
|
||||
Expression identifier = new IdentifierImpl(expression.getReferenceName(), isNullable);
|
||||
|
||||
final String __ = "__";
|
||||
if (hasReceiver)
|
||||
identifier = new CallChainExpression(new IdentifierImpl(__, false), new IdentifierImpl(expression.getReferenceName(), isNullable));
|
||||
else if (insideSecondaryConstructor && isThis)
|
||||
identifier = new IdentifierImpl("val __ = " + className); // TODO: hack
|
||||
|
||||
myResult = new CallChainExpression(
|
||||
expressionToExpression(expression.getQualifierExpression()),
|
||||
identifier // TODO: if type exists so identifier is nullable
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getClassNameWithConstructor(@NotNull PsiReferenceExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor()) {
|
||||
final PsiClass containingClass = ((PsiMethod) context).getContainingClass();
|
||||
if (containingClass != null) {
|
||||
final PsiIdentifier identifier = containingClass.getNameIdentifier();
|
||||
if (identifier != null)
|
||||
return identifier.getText();
|
||||
if (!secondOp.isEmpty()) // if not Kotlin operators
|
||||
{
|
||||
myResult = new AssignmentExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
new BinaryExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
expressionToExpression(expression.getRExpression()),
|
||||
secondOp
|
||||
),
|
||||
"="
|
||||
);
|
||||
}
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
static String getClassName(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiClass) {
|
||||
final PsiClass containingClass = (PsiClass) context;
|
||||
final PsiIdentifier identifier = containingClass.getNameIdentifier();
|
||||
if (identifier != null)
|
||||
return identifier.getText();
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
private static boolean isFieldReference(@NotNull PsiReferenceExpression expression, PsiClass currentClass) {
|
||||
final PsiReference reference = expression.getReference();
|
||||
if (reference != null) {
|
||||
final PsiElement resolvedReference = reference.resolve();
|
||||
if (resolvedReference != null) {
|
||||
if (resolvedReference instanceof PsiField) {
|
||||
return ((PsiField) resolvedReference).getContainingClass() == currentClass;
|
||||
else {
|
||||
myResult = new AssignmentExpression(
|
||||
expressionToExpression(expression.getLExpression()),
|
||||
expressionToExpression(expression.getRExpression()),
|
||||
expression.getOperationSign().getText() // TODO
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static boolean isInsideSecondaryConstructor(@NotNull PsiReferenceExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor())
|
||||
return !isConstructorPrimary((PsiMethod) context);
|
||||
context = context.getContext();
|
||||
@NotNull
|
||||
private static String getOperatorString(@NotNull IElementType tokenType) {
|
||||
if (tokenType == JavaTokenType.PLUS) return "+";
|
||||
if (tokenType == JavaTokenType.MINUS) return "-";
|
||||
if (tokenType == JavaTokenType.ASTERISK) return "*";
|
||||
if (tokenType == JavaTokenType.DIV) return "/";
|
||||
if (tokenType == JavaTokenType.PERC) return "%";
|
||||
if (tokenType == JavaTokenType.GTGT) return "shr";
|
||||
if (tokenType == JavaTokenType.LTLT) return "shl";
|
||||
if (tokenType == JavaTokenType.XOR) return "xor";
|
||||
if (tokenType == JavaTokenType.AND) return "and";
|
||||
if (tokenType == JavaTokenType.OR) return "or";
|
||||
if (tokenType == JavaTokenType.GTGTGT) return "ushr";
|
||||
if (tokenType == JavaTokenType.GT) return ">";
|
||||
if (tokenType == JavaTokenType.LT) return "<";
|
||||
if (tokenType == JavaTokenType.GE) return ">=";
|
||||
if (tokenType == JavaTokenType.LE) return "<=";
|
||||
if (tokenType == JavaTokenType.EQEQ) return "==";
|
||||
if (tokenType == JavaTokenType.NE) return "!=";
|
||||
if (tokenType == JavaTokenType.ANDAND) return "&&";
|
||||
if (tokenType == JavaTokenType.OROR) return "||";
|
||||
if (tokenType == JavaTokenType.PLUSPLUS) return "++";
|
||||
if (tokenType == JavaTokenType.MINUSMINUS) return "--";
|
||||
if (tokenType == JavaTokenType.EXCL) return "!";
|
||||
|
||||
System.out.println("UNSUPPORTED TOKEN TYPE: " + tokenType.toString());
|
||||
return "";
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static boolean isInsidePrimaryConstructor(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor())
|
||||
return isConstructorPrimary((PsiMethod) context);
|
||||
context = context.getContext();
|
||||
@Override
|
||||
public void visitBinaryExpression(@NotNull PsiBinaryExpression expression) {
|
||||
super.visitBinaryExpression(expression);
|
||||
|
||||
if (expression.getOperationSign().getTokenType() == JavaTokenType.GTGTGT) {
|
||||
myResult = new DummyMethodCallExpression(
|
||||
expressionToExpression(expression.getLOperand()),
|
||||
"ushr",
|
||||
expressionToExpression(expression.getROperand()));
|
||||
}
|
||||
else {
|
||||
myResult =
|
||||
new BinaryExpression(
|
||||
expressionToExpression(expression.getLOperand()),
|
||||
expressionToExpression(expression.getROperand()),
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
createConversions(expression, PsiType.BOOLEAN)
|
||||
);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiClass getContainingClass(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor())
|
||||
return ((PsiMethod) context).getContainingClass();
|
||||
context = context.getContext();
|
||||
@Override
|
||||
public void visitClassObjectAccessExpression(@NotNull PsiClassObjectAccessExpression expression) {
|
||||
super.visitClassObjectAccessExpression(expression);
|
||||
myResult = new ClassObjectAccessExpression(elementToElement(expression.getOperand()));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static boolean isThisExpression(@NotNull PsiReferenceExpression expression) {
|
||||
for (PsiReference r : expression.getReferences())
|
||||
if (r.getCanonicalText().equals("this")) {
|
||||
final PsiElement res = r.resolve();
|
||||
if (res != null && res instanceof PsiMethod && ((PsiMethod) res).isConstructor())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSuperExpression(@NotNull PsiSuperExpression expression) {
|
||||
super.visitSuperExpression(expression);
|
||||
final PsiJavaCodeReferenceElement qualifier = expression.getQualifier();
|
||||
myResult = new SuperExpression(
|
||||
qualifier != null ?
|
||||
new IdentifierImpl(qualifier.getQualifiedName()) :
|
||||
Identifier.EMPTY_IDENTIFIER
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitThisExpression(@NotNull PsiThisExpression expression) {
|
||||
super.visitThisExpression(expression);
|
||||
final PsiJavaCodeReferenceElement qualifier = expression.getQualifier();
|
||||
myResult = new ThisExpression(
|
||||
qualifier != null ?
|
||||
new IdentifierImpl(qualifier.getQualifiedName()) :
|
||||
Identifier.EMPTY_IDENTIFIER
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
|
||||
super.visitTypeCastExpression(expression);
|
||||
|
||||
final PsiTypeElement castType = expression.getCastType();
|
||||
if (castType != null) {
|
||||
myResult = new TypeCastExpression(
|
||||
typeToType(castType.getType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
@Override
|
||||
public void visitConditionalExpression(@NotNull PsiConditionalExpression expression) {
|
||||
super.visitConditionalExpression(expression);
|
||||
PsiExpression condition = expression.getCondition();
|
||||
PsiType type = condition.getType();
|
||||
Expression e = type != null ?
|
||||
createSureCallOnlyForChain(condition, type) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new ParenthesizedExpression(
|
||||
new IfStatement(
|
||||
e,
|
||||
expressionToExpression(expression.getThenExpression()),
|
||||
expressionToExpression(expression.getElseExpression())
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPolyadicExpression(@NotNull PsiPolyadicExpression expression) {
|
||||
super.visitPolyadicExpression(expression);
|
||||
myResult = new PolyadicExpression(
|
||||
expressionsToExpressionList(expression.getOperands()),
|
||||
getOperatorString(expression.getOperationTokenType()),
|
||||
createConversions(expression, PsiType.BOOLEAN)
|
||||
);
|
||||
}
|
||||
@Override
|
||||
public void visitExpressionList(@NotNull PsiExpressionList list) {
|
||||
super.visitExpressionList(list);
|
||||
myResult = new ExpressionList(expressionsToExpressionList(list.getExpressions()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitInstanceOfExpression(@NotNull PsiInstanceOfExpression expression) {
|
||||
super.visitInstanceOfExpression(expression);
|
||||
myResult = new IsOperator(
|
||||
expressionToExpression(expression.getOperand()),
|
||||
elementToElement(expression.getCheckType()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitLiteralExpression(@NotNull PsiLiteralExpression expression) {
|
||||
super.visitLiteralExpression(expression);
|
||||
|
||||
final Object value = expression.getValue();
|
||||
String text = expression.getText();
|
||||
boolean isQuotingNeeded = true;
|
||||
|
||||
final PsiType type = expression.getType();
|
||||
if (type != null) {
|
||||
String canonicalTypeStr = type.getCanonicalText();
|
||||
if (canonicalTypeStr.equals("double") || canonicalTypeStr.equals(JAVA_LANG_DOUBLE)) {
|
||||
text = text.replace("D", "").replace("d", "");
|
||||
}
|
||||
if (canonicalTypeStr.equals("float") || canonicalTypeStr.equals(JAVA_LANG_FLOAT)) {
|
||||
text = text.replace("F", "").replace("f", "") + "." + "flt";
|
||||
}
|
||||
if (canonicalTypeStr.equals("long") || canonicalTypeStr.equals(JAVA_LANG_LONG)) {
|
||||
text = text.replace("L", "").replace("l", "");
|
||||
}
|
||||
if (canonicalTypeStr.equals("int") || canonicalTypeStr.equals(JAVA_LANG_INTEGER)) // need for hex support
|
||||
{
|
||||
text = value != null ? value.toString() : text;
|
||||
}
|
||||
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_STRING)) {
|
||||
isQuotingNeeded = false;
|
||||
}
|
||||
if (canonicalTypeStr.equals("char") || canonicalTypeStr.equals(JAVA_LANG_CHARACTER)) {
|
||||
isQuotingNeeded = false;
|
||||
}
|
||||
}
|
||||
myResult = new LiteralExpression(new IdentifierImpl(text, false, isQuotingNeeded));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
|
||||
super.visitMethodCallExpression(expression);
|
||||
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())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitCallExpression(PsiCallExpression callExpression) {
|
||||
super.visitCallExpression(callExpression);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitNewExpression(@NotNull PsiNewExpression expression) {
|
||||
super.visitNewExpression(expression);
|
||||
if (expression.getArrayInitializer() != null) // new Foo[] {Foo(1), Foo(2)}
|
||||
{
|
||||
myResult = createNewEmptyArray(expression);
|
||||
}
|
||||
else if (expression.getArrayDimensions().length > 0) { // new Foo[5]
|
||||
myResult = createNewEmptyArrayWithoutInitialization(expression);
|
||||
}
|
||||
else { // new Class(): common case
|
||||
myResult = createNewClassExpression(expression);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static 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());
|
||||
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
|
||||
);
|
||||
}
|
||||
// is constructor secondary
|
||||
final PsiJavaCodeReferenceElement reference = expression.getClassReference();
|
||||
final List<Type> typeParameters = reference != null
|
||||
? typesToTypeList(reference.getTypeParameters())
|
||||
: Collections.<Type>emptyList();
|
||||
return new CallChainExpression(
|
||||
new IdentifierImpl(constructor.getName(), false),
|
||||
new MethodCallExpression(
|
||||
new IdentifierImpl("init"),
|
||||
expressionsToExpressionList(arguments),
|
||||
typeParameters));
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static Expression createNewEmptyArrayWithoutInitialization(@NotNull PsiNewExpression expression) {
|
||||
return new ArrayWithoutInitializationExpression(
|
||||
typeToType(expression.getType(), true),
|
||||
expressionsToExpressionList(expression.getArrayDimensions())
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static Expression createNewEmptyArray(@NotNull PsiNewExpression expression) {
|
||||
return expressionToExpression(expression.getArrayInitializer());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitParenthesizedExpression(@NotNull PsiParenthesizedExpression expression) {
|
||||
super.visitParenthesizedExpression(expression);
|
||||
myResult = new ParenthesizedExpression(
|
||||
expressionToExpression(expression.getExpression())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPostfixExpression(@NotNull PsiPostfixExpression expression) {
|
||||
super.visitPostfixExpression(expression);
|
||||
myResult = new PostfixOperator(
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPrefixExpression(@NotNull PsiPrefixExpression expression) {
|
||||
super.visitPrefixExpression(expression);
|
||||
if (expression.getOperationTokenType() == JavaTokenType.TILDE) {
|
||||
myResult = new DummyMethodCallExpression(
|
||||
new ParenthesizedExpression(expressionToExpression(expression.getOperand())), "inv", Expression.EMPTY_EXPRESSION
|
||||
);
|
||||
}
|
||||
else {
|
||||
myResult = new PrefixOperator(
|
||||
getOperatorString(expression.getOperationSign().getTokenType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
|
||||
final boolean isFieldReference = isFieldReference(expression, getContainingClass(expression));
|
||||
final boolean insideSecondaryConstructor = isInsideSecondaryConstructor(expression);
|
||||
final boolean hasReceiver = isFieldReference && insideSecondaryConstructor;
|
||||
final boolean isThis = isThisExpression(expression);
|
||||
final boolean isNullable = typeToType(expression.getType()).isNullable();
|
||||
final String className = getClassNameWithConstructor(expression);
|
||||
|
||||
Expression identifier = new IdentifierImpl(expression.getReferenceName(), isNullable);
|
||||
|
||||
final String __ = "__";
|
||||
if (hasReceiver) {
|
||||
identifier = new CallChainExpression(new IdentifierImpl(__, false), new IdentifierImpl(expression.getReferenceName(), isNullable));
|
||||
}
|
||||
else if (insideSecondaryConstructor && isThis) {
|
||||
identifier = new IdentifierImpl("val __ = " + className); // TODO: hack
|
||||
}
|
||||
|
||||
myResult = new CallChainExpression(
|
||||
expressionToExpression(expression.getQualifierExpression()),
|
||||
identifier // TODO: if type exists so identifier is nullable
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getClassNameWithConstructor(@NotNull PsiReferenceExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor()) {
|
||||
final PsiClass containingClass = ((PsiMethod) context).getContainingClass();
|
||||
if (containingClass != null) {
|
||||
final PsiIdentifier identifier = containingClass.getNameIdentifier();
|
||||
if (identifier != null) {
|
||||
return identifier.getText();
|
||||
}
|
||||
}
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
@NotNull
|
||||
static String getClassName(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiClass) {
|
||||
final PsiClass containingClass = (PsiClass) context;
|
||||
final PsiIdentifier identifier = containingClass.getNameIdentifier();
|
||||
if (identifier != null) {
|
||||
return identifier.getText();
|
||||
}
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
private static boolean isFieldReference(@NotNull PsiReferenceExpression expression, PsiClass currentClass) {
|
||||
final PsiReference reference = expression.getReference();
|
||||
if (reference != null) {
|
||||
final PsiElement resolvedReference = reference.resolve();
|
||||
if (resolvedReference != null) {
|
||||
if (resolvedReference instanceof PsiField) {
|
||||
return ((PsiField) resolvedReference).getContainingClass() == currentClass;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static boolean isInsideSecondaryConstructor(@NotNull PsiReferenceExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor()) {
|
||||
return !isConstructorPrimary((PsiMethod) context);
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static boolean isInsidePrimaryConstructor(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor()) {
|
||||
return isConstructorPrimary((PsiMethod) context);
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
private static PsiClass getContainingClass(@NotNull PsiExpression expression) {
|
||||
PsiElement context = expression.getContext();
|
||||
while (context != null) {
|
||||
if (context instanceof PsiMethod && ((PsiMethod) context).isConstructor()) {
|
||||
return ((PsiMethod) context).getContainingClass();
|
||||
}
|
||||
context = context.getContext();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static boolean isThisExpression(@NotNull PsiReferenceExpression expression) {
|
||||
for (PsiReference r : expression.getReferences())
|
||||
if (r.getCanonicalText().equals("this")) {
|
||||
final PsiElement res = r.resolve();
|
||||
if (res != null && res instanceof PsiMethod && ((PsiMethod) res).isConstructor()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSuperExpression(@NotNull PsiSuperExpression expression) {
|
||||
super.visitSuperExpression(expression);
|
||||
final PsiJavaCodeReferenceElement qualifier = expression.getQualifier();
|
||||
myResult = new SuperExpression(
|
||||
qualifier != null ?
|
||||
new IdentifierImpl(qualifier.getQualifiedName()) :
|
||||
Identifier.EMPTY_IDENTIFIER
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitThisExpression(@NotNull PsiThisExpression expression) {
|
||||
super.visitThisExpression(expression);
|
||||
final PsiJavaCodeReferenceElement qualifier = expression.getQualifier();
|
||||
myResult = new ThisExpression(
|
||||
qualifier != null ?
|
||||
new IdentifierImpl(qualifier.getQualifiedName()) :
|
||||
Identifier.EMPTY_IDENTIFIER
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
|
||||
super.visitTypeCastExpression(expression);
|
||||
|
||||
final PsiTypeElement castType = expression.getCastType();
|
||||
if (castType != null) {
|
||||
myResult = new TypeCastExpression(
|
||||
typeToType(castType.getType()),
|
||||
expressionToExpression(expression.getOperand())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitPolyadicExpression(@NotNull PsiPolyadicExpression expression) {
|
||||
super.visitPolyadicExpression(expression);
|
||||
myResult = new PolyadicExpression(
|
||||
expressionsToExpressionList(expression.getOperands()),
|
||||
getOperatorString(expression.getOperationTokenType()),
|
||||
createConversions(expression, PsiType.BOOLEAN)
|
||||
);
|
||||
}
|
||||
}
|
||||
+33
-28
@@ -13,33 +13,38 @@ import static org.jetbrains.jet.j2k.visitors.TypeVisitor.JAVA_LANG_OBJECT;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ExpressionVisitorForDirectObjectInheritors extends ExpressionVisitor {
|
||||
@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()));
|
||||
else if (superMethodInvocation(expression.getMethodExpression(), "toString"))
|
||||
myResult = new DummyStringExpression(String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())", getClassName(expression.getMethodExpression())));
|
||||
else
|
||||
super.visitMethodCallExpression(expression);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull final PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
}
|
||||
|
||||
private static boolean superMethodInvocation(@NotNull final PsiReferenceExpression expression, final String methodName) {
|
||||
String referenceName = expression.getReferenceName();
|
||||
PsiExpression qualifierExpression = expression.getQualifierExpression();
|
||||
if (referenceName != null && referenceName.equals(methodName)) {
|
||||
if (qualifierExpression instanceof PsiSuperExpression) {
|
||||
PsiType type = qualifierExpression.getType();
|
||||
if (type != null && type.getCanonicalText().equals(JAVA_LANG_OBJECT))
|
||||
return true;
|
||||
}
|
||||
@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()));
|
||||
}
|
||||
else if (superMethodInvocation(expression.getMethodExpression(), "toString")) {
|
||||
myResult = new DummyStringExpression(String.format("getJavaClass<%s>.getName() + '@' + Integer.toHexString(hashCode())", getClassName(expression.getMethodExpression())));
|
||||
}
|
||||
else {
|
||||
super.visitMethodCallExpression(expression);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull final PsiReferenceExpression expression) {
|
||||
super.visitReferenceExpression(expression);
|
||||
}
|
||||
|
||||
private static boolean superMethodInvocation(@NotNull final PsiReferenceExpression expression, final String methodName) {
|
||||
String referenceName = expression.getReferenceName();
|
||||
PsiExpression qualifierExpression = expression.getQualifierExpression();
|
||||
if (referenceName != null && referenceName.equals(methodName)) {
|
||||
if (qualifierExpression instanceof PsiSuperExpression) {
|
||||
PsiType type = qualifierExpression.getType();
|
||||
if (type != null && type.getCanonicalText().equals(JAVA_LANG_OBJECT)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,341 +19,358 @@ import static org.jetbrains.jet.j2k.ConverterUtil.countWritingAccesses;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class StatementVisitor extends ElementVisitor {
|
||||
private Statement myResult = Statement.EMPTY_STATEMENT;
|
||||
private Statement myResult = Statement.EMPTY_STATEMENT;
|
||||
|
||||
@NotNull
|
||||
@Override
|
||||
public Statement getResult() {
|
||||
return myResult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitAssertStatement(@NotNull PsiAssertStatement statement) {
|
||||
super.visitAssertStatement(statement);
|
||||
myResult = new AssertStatement(
|
||||
expressionToExpression(statement.getAssertCondition()),
|
||||
expressionToExpression(statement.getAssertDescription())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBlockStatement(@NotNull PsiBlockStatement statement) {
|
||||
super.visitBlockStatement(statement);
|
||||
myResult = new Block(
|
||||
statementsToStatementList(statement.getCodeBlock().getStatements()),
|
||||
true
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBreakStatement(@NotNull PsiBreakStatement statement) {
|
||||
super.visitBreakStatement(statement);
|
||||
if (statement.getLabelIdentifier() == null)
|
||||
myResult = new BreakStatement();
|
||||
else
|
||||
myResult = new BreakStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitContinueStatement(@NotNull PsiContinueStatement statement) {
|
||||
super.visitContinueStatement(statement);
|
||||
if (statement.getLabelIdentifier() == null)
|
||||
myResult = new ContinueStatement();
|
||||
else
|
||||
myResult = new ContinueStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitDeclarationStatement(@NotNull PsiDeclarationStatement statement) {
|
||||
super.visitDeclarationStatement(statement);
|
||||
myResult = new DeclarationStatement(
|
||||
elementsToElementList(statement.getDeclaredElements())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitDoWhileStatement(@NotNull PsiDoWhileStatement statement) {
|
||||
super.visitDoWhileStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new DoWhileStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) {
|
||||
super.visitExpressionStatement(statement);
|
||||
myResult = expressionToExpression(statement.getExpression());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionListStatement(@NotNull PsiExpressionListStatement statement) {
|
||||
super.visitExpressionListStatement(statement);
|
||||
myResult =
|
||||
new ExpressionListStatement(expressionsToExpressionList(statement.getExpressionList().getExpressions()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitForStatement(@NotNull PsiForStatement statement) {
|
||||
super.visitForStatement(statement);
|
||||
|
||||
final PsiStatement initialization = statement.getInitialization();
|
||||
final PsiStatement update = statement.getUpdate();
|
||||
final PsiExpression condition = statement.getCondition();
|
||||
final PsiStatement body = statement.getBody();
|
||||
|
||||
final PsiLocalVariable firstChild = initialization != null && initialization.getFirstChild() instanceof PsiLocalVariable ?
|
||||
(PsiLocalVariable) initialization.getFirstChild() : null;
|
||||
|
||||
int bodyWriteCount = countWritingAccesses(firstChild, body);
|
||||
int conditionWriteCount = countWritingAccesses(firstChild, condition);
|
||||
int updateWriteCount = countWritingAccesses(firstChild, update);
|
||||
boolean onceWritableIterator = updateWriteCount == 1 && bodyWriteCount + conditionWriteCount == 0;
|
||||
|
||||
final IElementType operationTokenType = condition != null && condition instanceof PsiBinaryExpression ?
|
||||
((PsiBinaryExpression) condition).getOperationTokenType() : null;
|
||||
if (
|
||||
initialization != null &&
|
||||
initialization instanceof PsiDeclarationStatement
|
||||
&& initialization.getFirstChild() == initialization.getLastChild()
|
||||
&& condition != null
|
||||
&& update != null
|
||||
&& update.getChildren().length == 1
|
||||
&& isPlusPlusExpression(update.getChildren()[0])
|
||||
&& operationTokenType != null
|
||||
&& (operationTokenType == JavaTokenType.LT || operationTokenType == JavaTokenType.LE)
|
||||
&& initialization.getFirstChild() != null
|
||||
&& initialization.getFirstChild() instanceof PsiLocalVariable
|
||||
&& firstChild != null
|
||||
&& firstChild.getNameIdentifier() != null
|
||||
&& onceWritableIterator
|
||||
) {
|
||||
final Expression end = 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()),
|
||||
endExpression,
|
||||
statementToStatement(body)
|
||||
);
|
||||
} else { // common case: while loop instead of for loop
|
||||
List<Statement> forStatements = new LinkedList<Statement>();
|
||||
forStatements.add(statementToStatement(initialization));
|
||||
forStatements.add(new WhileStatement(
|
||||
expressionToExpression(condition),
|
||||
new Block(
|
||||
Arrays.asList(statementToStatement(body),
|
||||
new Block(Arrays.asList(statementToStatement(update)))))));
|
||||
myResult = new Block(forStatements);
|
||||
@NotNull
|
||||
@Override
|
||||
public Statement getResult() {
|
||||
return myResult;
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean isPlusPlusExpression(@NotNull PsiElement psiElement) {
|
||||
return (psiElement instanceof PsiPostfixExpression && ((PsiPostfixExpression) psiElement).getOperationTokenType() == JavaTokenType.PLUSPLUS)
|
||||
|| (psiElement instanceof PsiPrefixExpression && ((PsiPrefixExpression) psiElement).getOperationTokenType() == JavaTokenType.PLUSPLUS);
|
||||
}
|
||||
@Override
|
||||
public void visitAssertStatement(@NotNull PsiAssertStatement statement) {
|
||||
super.visitAssertStatement(statement);
|
||||
myResult = new AssertStatement(
|
||||
expressionToExpression(statement.getAssertCondition()),
|
||||
expressionToExpression(statement.getAssertDescription())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitForeachStatement(@NotNull PsiForeachStatement statement) {
|
||||
super.visitForeachStatement(statement);
|
||||
myResult = new ForeachStatement(
|
||||
parameterToParameter(statement.getIterationParameter()),
|
||||
expressionToExpression(statement.getIteratedValue()),
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
@Override
|
||||
public void visitBlockStatement(@NotNull PsiBlockStatement statement) {
|
||||
super.visitBlockStatement(statement);
|
||||
myResult = new Block(
|
||||
statementsToStatementList(statement.getCodeBlock().getStatements()),
|
||||
true
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitIfStatement(@NotNull PsiIfStatement statement) {
|
||||
super.visitIfStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new IfStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getThenBranch()),
|
||||
statementToStatement(statement.getElseBranch())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitLabeledStatement(@NotNull PsiLabeledStatement statement) {
|
||||
super.visitLabeledStatement(statement);
|
||||
myResult = new LabelStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier()),
|
||||
statementToStatement(statement.getStatement())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSwitchLabelStatement(@NotNull PsiSwitchLabelStatement statement) {
|
||||
super.visitSwitchLabelStatement(statement);
|
||||
myResult = statement.isDefaultCase() ?
|
||||
new DefaultSwitchLabelStatement() :
|
||||
new SwitchLabelStatement(expressionToExpression(statement.getCaseValue()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSwitchStatement(@NotNull PsiSwitchStatement statement) {
|
||||
super.visitSwitchStatement(statement);
|
||||
myResult = new SwitchContainer(
|
||||
expressionToExpression(statement.getExpression()),
|
||||
switchBodyToCases(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<CaseContainer> switchBodyToCases(@Nullable final PsiCodeBlock body) {
|
||||
final List<List<PsiStatement>> cases = splitToCases(body);
|
||||
final List<PsiStatement> allSwitchStatements = body != null ? Arrays.asList(body.getStatements()) : Collections.<PsiStatement>emptyList();
|
||||
|
||||
List<CaseContainer> result = new LinkedList<CaseContainer>();
|
||||
List<Statement> pendingLabels = new LinkedList<Statement>();
|
||||
int i = 0;
|
||||
for (List<PsiStatement> ls : cases) {
|
||||
assert ls.size() > 0;
|
||||
PsiStatement label = ls.get(0);
|
||||
assert label instanceof PsiSwitchLabelStatement;
|
||||
|
||||
assert allSwitchStatements.get(i) == label : "not a right index";
|
||||
|
||||
if (ls.size() > 1) {
|
||||
pendingLabels.add(statementToStatement(label));
|
||||
List<PsiStatement> slice = ls.subList(1, ls.size());
|
||||
|
||||
if (!containsBreak(slice)) {
|
||||
List<Statement> statements = statementsToStatementList(slice);
|
||||
statements.addAll(
|
||||
statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size()))
|
||||
);
|
||||
result.add(new CaseContainer(pendingLabels, statements));
|
||||
pendingLabels = new LinkedList<Statement>();
|
||||
} else {
|
||||
result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice)));
|
||||
pendingLabels = new LinkedList<Statement>();
|
||||
@Override
|
||||
public void visitBreakStatement(@NotNull PsiBreakStatement statement) {
|
||||
super.visitBreakStatement(statement);
|
||||
if (statement.getLabelIdentifier() == null) {
|
||||
myResult = new BreakStatement();
|
||||
}
|
||||
else {
|
||||
myResult = new BreakStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier())
|
||||
);
|
||||
}
|
||||
} else // ls.size() == 1
|
||||
pendingLabels.add(statementToStatement(label));
|
||||
i += ls.size();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private static boolean containsBreak(@NotNull final List<PsiStatement> slice) {
|
||||
for (PsiStatement s : slice)
|
||||
if (s instanceof PsiBreakStatement)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
@Override
|
||||
public void visitContinueStatement(@NotNull PsiContinueStatement statement) {
|
||||
super.visitContinueStatement(statement);
|
||||
if (statement.getLabelIdentifier() == null) {
|
||||
myResult = new ContinueStatement();
|
||||
}
|
||||
else {
|
||||
myResult = new ContinueStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier())
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<PsiStatement> getAllToNextBreak(@NotNull final List<PsiStatement> allStatements, final int start) {
|
||||
List<PsiStatement> result = new LinkedList<PsiStatement>();
|
||||
for (int i = start; i < allStatements.size(); i++) {
|
||||
PsiStatement s = allStatements.get(i);
|
||||
if (s instanceof PsiBreakStatement || s instanceof PsiReturnStatement)
|
||||
@Override
|
||||
public void visitDeclarationStatement(@NotNull PsiDeclarationStatement statement) {
|
||||
super.visitDeclarationStatement(statement);
|
||||
myResult = new DeclarationStatement(
|
||||
elementsToElementList(statement.getDeclaredElements())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitDoWhileStatement(@NotNull PsiDoWhileStatement statement) {
|
||||
super.visitDoWhileStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new DoWhileStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) {
|
||||
super.visitExpressionStatement(statement);
|
||||
myResult = expressionToExpression(statement.getExpression());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitExpressionListStatement(@NotNull PsiExpressionListStatement statement) {
|
||||
super.visitExpressionListStatement(statement);
|
||||
myResult =
|
||||
new ExpressionListStatement(expressionsToExpressionList(statement.getExpressionList().getExpressions()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitForStatement(@NotNull PsiForStatement statement) {
|
||||
super.visitForStatement(statement);
|
||||
|
||||
final PsiStatement initialization = statement.getInitialization();
|
||||
final PsiStatement update = statement.getUpdate();
|
||||
final PsiExpression condition = statement.getCondition();
|
||||
final PsiStatement body = statement.getBody();
|
||||
|
||||
final PsiLocalVariable firstChild = initialization != null && initialization.getFirstChild() instanceof PsiLocalVariable
|
||||
?
|
||||
(PsiLocalVariable) initialization.getFirstChild()
|
||||
: null;
|
||||
|
||||
int bodyWriteCount = countWritingAccesses(firstChild, body);
|
||||
int conditionWriteCount = countWritingAccesses(firstChild, condition);
|
||||
int updateWriteCount = countWritingAccesses(firstChild, update);
|
||||
boolean onceWritableIterator = updateWriteCount == 1 && bodyWriteCount + conditionWriteCount == 0;
|
||||
|
||||
final IElementType operationTokenType = condition != null && condition instanceof PsiBinaryExpression ?
|
||||
((PsiBinaryExpression) condition).getOperationTokenType() : null;
|
||||
if (
|
||||
initialization != null &&
|
||||
initialization instanceof PsiDeclarationStatement
|
||||
&& initialization.getFirstChild() == initialization.getLastChild()
|
||||
&& condition != null
|
||||
&& update != null
|
||||
&& update.getChildren().length == 1
|
||||
&& isPlusPlusExpression(update.getChildren()[0])
|
||||
&& operationTokenType != null
|
||||
&& (operationTokenType == JavaTokenType.LT || operationTokenType == JavaTokenType.LE)
|
||||
&& initialization.getFirstChild() != null
|
||||
&& initialization.getFirstChild() instanceof PsiLocalVariable
|
||||
&& firstChild != null
|
||||
&& firstChild.getNameIdentifier() != null
|
||||
&& onceWritableIterator
|
||||
) {
|
||||
final Expression end = 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()),
|
||||
endExpression,
|
||||
statementToStatement(body)
|
||||
);
|
||||
}
|
||||
else { // common case: while loop instead of for loop
|
||||
List<Statement> forStatements = new LinkedList<Statement>();
|
||||
forStatements.add(statementToStatement(initialization));
|
||||
forStatements.add(new WhileStatement(
|
||||
expressionToExpression(condition),
|
||||
new Block(
|
||||
Arrays.asList(statementToStatement(body),
|
||||
new Block(Arrays.asList(statementToStatement(update)))))));
|
||||
myResult = new Block(forStatements);
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean isPlusPlusExpression(@NotNull PsiElement psiElement) {
|
||||
return (psiElement instanceof PsiPostfixExpression && ((PsiPostfixExpression) psiElement).getOperationTokenType() == JavaTokenType.PLUSPLUS)
|
||||
|| (psiElement instanceof PsiPrefixExpression && ((PsiPrefixExpression) psiElement).getOperationTokenType() == JavaTokenType.PLUSPLUS);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitForeachStatement(@NotNull PsiForeachStatement statement) {
|
||||
super.visitForeachStatement(statement);
|
||||
myResult = new ForeachStatement(
|
||||
parameterToParameter(statement.getIterationParameter()),
|
||||
expressionToExpression(statement.getIteratedValue()),
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitIfStatement(@NotNull PsiIfStatement statement) {
|
||||
super.visitIfStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new IfStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getThenBranch()),
|
||||
statementToStatement(statement.getElseBranch())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitLabeledStatement(@NotNull PsiLabeledStatement statement) {
|
||||
super.visitLabeledStatement(statement);
|
||||
myResult = new LabelStatement(
|
||||
identifierToIdentifier(statement.getLabelIdentifier()),
|
||||
statementToStatement(statement.getStatement())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSwitchLabelStatement(@NotNull PsiSwitchLabelStatement statement) {
|
||||
super.visitSwitchLabelStatement(statement);
|
||||
myResult = statement.isDefaultCase() ?
|
||||
new DefaultSwitchLabelStatement() :
|
||||
new SwitchLabelStatement(expressionToExpression(statement.getCaseValue()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSwitchStatement(@NotNull PsiSwitchStatement statement) {
|
||||
super.visitSwitchStatement(statement);
|
||||
myResult = new SwitchContainer(
|
||||
expressionToExpression(statement.getExpression()),
|
||||
switchBodyToCases(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<CaseContainer> switchBodyToCases(@Nullable final PsiCodeBlock body) {
|
||||
final List<List<PsiStatement>> cases = splitToCases(body);
|
||||
final List<PsiStatement> allSwitchStatements = body != null
|
||||
? Arrays.asList(body.getStatements())
|
||||
: Collections.<PsiStatement>emptyList();
|
||||
|
||||
List<CaseContainer> result = new LinkedList<CaseContainer>();
|
||||
List<Statement> pendingLabels = new LinkedList<Statement>();
|
||||
int i = 0;
|
||||
for (List<PsiStatement> ls : cases) {
|
||||
assert ls.size() > 0;
|
||||
PsiStatement label = ls.get(0);
|
||||
assert label instanceof PsiSwitchLabelStatement;
|
||||
|
||||
assert allSwitchStatements.get(i) == label : "not a right index";
|
||||
|
||||
if (ls.size() > 1) {
|
||||
pendingLabels.add(statementToStatement(label));
|
||||
List<PsiStatement> slice = ls.subList(1, ls.size());
|
||||
|
||||
if (!containsBreak(slice)) {
|
||||
List<Statement> statements = statementsToStatementList(slice);
|
||||
statements.addAll(
|
||||
statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size()))
|
||||
);
|
||||
result.add(new CaseContainer(pendingLabels, statements));
|
||||
pendingLabels = new LinkedList<Statement>();
|
||||
}
|
||||
else {
|
||||
result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice)));
|
||||
pendingLabels = new LinkedList<Statement>();
|
||||
}
|
||||
}
|
||||
else // ls.size() == 1
|
||||
{
|
||||
pendingLabels.add(statementToStatement(label));
|
||||
}
|
||||
i += ls.size();
|
||||
}
|
||||
return result;
|
||||
if (!(s instanceof PsiSwitchLabelStatement))
|
||||
result.add(s);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<List<PsiStatement>> splitToCases(@Nullable final PsiCodeBlock body) {
|
||||
List<List<PsiStatement>> cases = new LinkedList<List<PsiStatement>>();
|
||||
List<PsiStatement> currentCaseStatements = new LinkedList<PsiStatement>();
|
||||
boolean isFirst = true;
|
||||
if (body != null) {
|
||||
for (PsiStatement s : body.getStatements()) {
|
||||
if (s instanceof PsiSwitchLabelStatement) {
|
||||
if (isFirst)
|
||||
isFirst = false;
|
||||
else {
|
||||
cases.add(currentCaseStatements);
|
||||
currentCaseStatements = new LinkedList<PsiStatement>();
|
||||
}
|
||||
private static boolean containsBreak(@NotNull final List<PsiStatement> slice) {
|
||||
for (PsiStatement s : slice)
|
||||
if (s instanceof PsiBreakStatement) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<PsiStatement> getAllToNextBreak(@NotNull final List<PsiStatement> allStatements, final int start) {
|
||||
List<PsiStatement> result = new LinkedList<PsiStatement>();
|
||||
for (int i = start; i < allStatements.size(); i++) {
|
||||
PsiStatement s = allStatements.get(i);
|
||||
if (s instanceof PsiBreakStatement || s instanceof PsiReturnStatement) {
|
||||
return result;
|
||||
}
|
||||
if (!(s instanceof PsiSwitchLabelStatement)) {
|
||||
result.add(s);
|
||||
}
|
||||
}
|
||||
currentCaseStatements.add(s);
|
||||
}
|
||||
cases.add(currentCaseStatements);
|
||||
}
|
||||
return cases;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitSynchronizedStatement(@NotNull PsiSynchronizedStatement statement) {
|
||||
super.visitSynchronizedStatement(statement);
|
||||
myResult = new SynchronizedStatement(
|
||||
expressionToExpression(statement.getLockExpression()),
|
||||
blockToBlock(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitThrowStatement(@NotNull PsiThrowStatement statement) {
|
||||
super.visitThrowStatement(statement);
|
||||
myResult = new ThrowStatement(
|
||||
expressionToExpression(statement.getException())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTryStatement(@NotNull PsiTryStatement statement) {
|
||||
super.visitTryStatement(statement);
|
||||
|
||||
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)
|
||||
));
|
||||
return result;
|
||||
}
|
||||
|
||||
myResult = new TryStatement(
|
||||
blockToBlock(statement.getTryBlock(), true),
|
||||
catches,
|
||||
blockToBlock(statement.getFinallyBlock(), true)
|
||||
);
|
||||
}
|
||||
@NotNull
|
||||
private static List<List<PsiStatement>> splitToCases(@Nullable final PsiCodeBlock body) {
|
||||
List<List<PsiStatement>> cases = new LinkedList<List<PsiStatement>>();
|
||||
List<PsiStatement> currentCaseStatements = new LinkedList<PsiStatement>();
|
||||
boolean isFirst = true;
|
||||
if (body != null) {
|
||||
for (PsiStatement s : body.getStatements()) {
|
||||
if (s instanceof PsiSwitchLabelStatement) {
|
||||
if (isFirst) {
|
||||
isFirst = false;
|
||||
}
|
||||
else {
|
||||
cases.add(currentCaseStatements);
|
||||
currentCaseStatements = new LinkedList<PsiStatement>();
|
||||
}
|
||||
}
|
||||
currentCaseStatements.add(s);
|
||||
}
|
||||
cases.add(currentCaseStatements);
|
||||
}
|
||||
return cases;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitWhileStatement(@NotNull PsiWhileStatement statement) {
|
||||
super.visitWhileStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new WhileStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
@Override
|
||||
public void visitSynchronizedStatement(@NotNull PsiSynchronizedStatement statement) {
|
||||
super.visitSynchronizedStatement(statement);
|
||||
myResult = new SynchronizedStatement(
|
||||
expressionToExpression(statement.getLockExpression()),
|
||||
blockToBlock(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReturnStatement(@NotNull PsiReturnStatement statement) {
|
||||
super.visitReturnStatement(statement);
|
||||
PsiExpression returnValue = statement.getReturnValue();
|
||||
PsiType methodReturnType = Converter.getMethodReturnType();
|
||||
Expression expression = returnValue != null && methodReturnType != null ?
|
||||
createSureCallOnlyForChain(returnValue, methodReturnType) :
|
||||
expressionToExpression(returnValue);
|
||||
myResult = new ReturnStatement(
|
||||
expression
|
||||
);
|
||||
}
|
||||
@Override
|
||||
public void visitThrowStatement(@NotNull PsiThrowStatement statement) {
|
||||
super.visitThrowStatement(statement);
|
||||
myResult = new ThrowStatement(
|
||||
expressionToExpression(statement.getException())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitTryStatement(@NotNull PsiTryStatement statement) {
|
||||
super.visitTryStatement(statement);
|
||||
|
||||
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)
|
||||
));
|
||||
}
|
||||
|
||||
myResult = new TryStatement(
|
||||
blockToBlock(statement.getTryBlock(), true),
|
||||
catches,
|
||||
blockToBlock(statement.getFinallyBlock(), true)
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitWhileStatement(@NotNull PsiWhileStatement statement) {
|
||||
super.visitWhileStatement(statement);
|
||||
PsiExpression condition = statement.getCondition();
|
||||
@SuppressWarnings("ConstantConditions")
|
||||
Expression expression = condition != null && condition.getType() != null ?
|
||||
createSureCallOnlyForChain(condition, condition.getType()) :
|
||||
expressionToExpression(condition);
|
||||
myResult = new WhileStatement(
|
||||
expression,
|
||||
statementToStatement(statement.getBody())
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitReturnStatement(@NotNull PsiReturnStatement statement) {
|
||||
super.visitReturnStatement(statement);
|
||||
PsiExpression returnValue = statement.getReturnValue();
|
||||
PsiType methodReturnType = Converter.getMethodReturnType();
|
||||
Expression expression = returnValue != null && methodReturnType != null ?
|
||||
createSureCallOnlyForChain(returnValue, methodReturnType) :
|
||||
expressionToExpression(returnValue);
|
||||
myResult = new ReturnStatement(
|
||||
expression
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,32 +10,33 @@ import java.util.HashSet;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class SuperVisitor extends JavaRecursiveElementVisitor {
|
||||
@NotNull
|
||||
private final HashSet<PsiExpressionList> myResolvedSuperCallParameters;
|
||||
@NotNull
|
||||
private final HashSet<PsiExpressionList> myResolvedSuperCallParameters;
|
||||
|
||||
public SuperVisitor() {
|
||||
myResolvedSuperCallParameters = new HashSet<PsiExpressionList>();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public HashSet<PsiExpressionList> getResolvedSuperCallParameters() {
|
||||
return myResolvedSuperCallParameters;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
|
||||
super.visitMethodCallExpression(expression);
|
||||
if (isSuper(expression.getMethodExpression()))
|
||||
myResolvedSuperCallParameters.add(expression.getArgumentList());
|
||||
}
|
||||
|
||||
static boolean isSuper(@NotNull PsiReference r) {
|
||||
if (r.getCanonicalText().equals("super")) {
|
||||
final PsiElement baseConstructor = r.resolve();
|
||||
if (baseConstructor != null && baseConstructor instanceof PsiMethod && ((PsiMethod) baseConstructor).isConstructor()) {
|
||||
return true;
|
||||
}
|
||||
public SuperVisitor() {
|
||||
myResolvedSuperCallParameters = new HashSet<PsiExpressionList>();
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public HashSet<PsiExpressionList> getResolvedSuperCallParameters() {
|
||||
return myResolvedSuperCallParameters;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
|
||||
super.visitMethodCallExpression(expression);
|
||||
if (isSuper(expression.getMethodExpression())) {
|
||||
myResolvedSuperCallParameters.add(expression.getArgumentList());
|
||||
}
|
||||
}
|
||||
|
||||
static boolean isSuper(@NotNull PsiReference r) {
|
||||
if (r.getCanonicalText().equals("super")) {
|
||||
final PsiElement baseConstructor = r.resolve();
|
||||
if (baseConstructor != null && baseConstructor instanceof PsiMethod && ((PsiMethod) baseConstructor).isConstructor()) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,28 +10,30 @@ import java.util.HashSet;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class ThisVisitor extends JavaRecursiveElementVisitor {
|
||||
@NotNull
|
||||
private final HashSet<PsiMethod> myResolvedConstructors = new HashSet<PsiMethod>();
|
||||
@NotNull
|
||||
private final HashSet<PsiMethod> myResolvedConstructors = new HashSet<PsiMethod>();
|
||||
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) {
|
||||
for (PsiReference r : expression.getReferences())
|
||||
if (r.getCanonicalText().equals("this")) {
|
||||
final PsiElement res = r.resolve();
|
||||
if (res != null && res instanceof PsiMethod && ((PsiMethod) res).isConstructor())
|
||||
myResolvedConstructors.add((PsiMethod) res);
|
||||
}
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public PsiMethod getPrimaryConstructor() {
|
||||
if (myResolvedConstructors.size() > 0) {
|
||||
PsiMethod first = myResolvedConstructors.toArray(new PsiMethod[myResolvedConstructors.size()])[0];
|
||||
for (PsiMethod m : myResolvedConstructors)
|
||||
if (m.hashCode() != first.hashCode())
|
||||
return null;
|
||||
return first;
|
||||
@Override
|
||||
public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) {
|
||||
for (PsiReference r : expression.getReferences())
|
||||
if (r.getCanonicalText().equals("this")) {
|
||||
final PsiElement res = r.resolve();
|
||||
if (res != null && res instanceof PsiMethod && ((PsiMethod) res).isConstructor()) {
|
||||
myResolvedConstructors.add((PsiMethod) res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public PsiMethod getPrimaryConstructor() {
|
||||
if (myResolvedConstructors.size() > 0) {
|
||||
PsiMethod first = myResolvedConstructors.toArray(new PsiMethod[myResolvedConstructors.size()])[0];
|
||||
for (PsiMethod m : myResolvedConstructors)
|
||||
if (m.hashCode() != first.hashCode()) {
|
||||
return null;
|
||||
}
|
||||
return first;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,160 +17,176 @@ import static org.jetbrains.jet.j2k.Converter.typesToTypeList;
|
||||
* @author ignatov
|
||||
*/
|
||||
public class TypeVisitor extends PsiTypeVisitor<Type> {
|
||||
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";
|
||||
public static final String JAVA_LANG_FLOAT = "java.lang.Float";
|
||||
public static final String JAVA_LANG_INTEGER = "java.lang.Integer";
|
||||
public static final String JAVA_LANG_LONG = "java.lang.Long";
|
||||
public static final String JAVA_LANG_SHORT = "java.lang.Short";
|
||||
private static final String JAVA_LANG_BOOLEAN = "java.lang.Boolean";
|
||||
public static final String JAVA_LANG_OBJECT = "java.lang.Object";
|
||||
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 Type myResult = Type.EMPTY_TYPE;
|
||||
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";
|
||||
public static final String JAVA_LANG_FLOAT = "java.lang.Float";
|
||||
public static final String JAVA_LANG_INTEGER = "java.lang.Integer";
|
||||
public static final String JAVA_LANG_LONG = "java.lang.Long";
|
||||
public static final String JAVA_LANG_SHORT = "java.lang.Short";
|
||||
private static final String JAVA_LANG_BOOLEAN = "java.lang.Boolean";
|
||||
public static final String JAVA_LANG_OBJECT = "java.lang.Object";
|
||||
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 Type myResult = Type.EMPTY_TYPE;
|
||||
|
||||
@NotNull
|
||||
public Type getResult() {
|
||||
return myResult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitPrimitiveType(@NotNull PsiPrimitiveType primitiveType) {
|
||||
final String name = primitiveType.getCanonicalText();
|
||||
final IdentifierImpl identifier = new IdentifierImpl(name);
|
||||
|
||||
if (name.equals("void"))
|
||||
myResult = new PrimitiveType(new IdentifierImpl("Unit"));
|
||||
else if (Node.PRIMITIVE_TYPES.contains(name))
|
||||
myResult = new PrimitiveType(new IdentifierImpl(AstUtil.upperFirstCharacter(name)));
|
||||
else
|
||||
myResult = new PrimitiveType(identifier);
|
||||
return super.visitPrimitiveType(primitiveType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitArrayType(@NotNull PsiArrayType arrayType) {
|
||||
if (myResult == Type.EMPTY_TYPE)
|
||||
myResult = new ArrayType(typeToType(arrayType.getComponentType()));
|
||||
return super.visitArrayType(arrayType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitClassType(@NotNull PsiClassType classType) {
|
||||
final IdentifierImpl identifier = constructClassTypeIdentifier(classType);
|
||||
final List<Type> resolvedClassTypeParams = createRawTypesForResolvedReference(classType);
|
||||
|
||||
if (classType.getParameterCount() == 0 && resolvedClassTypeParams.size() > 0)
|
||||
myResult = new ClassType(identifier, resolvedClassTypeParams);
|
||||
else
|
||||
myResult = new ClassType(identifier, typesToTypeList(classType.getParameters()));
|
||||
return super.visitClassType(classType);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static 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.hasSetting("fqn"))
|
||||
return new IdentifierImpl(qualifiedName);
|
||||
if (qualifiedName.equals(JAVA_LANG_ITERABLE))
|
||||
return new IdentifierImpl(JAVA_LANG_ITERABLE);
|
||||
if (qualifiedName.equals(JAVA_UTIL_ITERATOR))
|
||||
return new IdentifierImpl(JAVA_UTIL_ITERATOR);
|
||||
}
|
||||
@NotNull
|
||||
public Type getResult() {
|
||||
return myResult;
|
||||
}
|
||||
final String classTypeName = createQualifiedName(classType);
|
||||
|
||||
if (classTypeName.isEmpty())
|
||||
return new IdentifierImpl(getClassTypeName(classType));
|
||||
@Override
|
||||
public Type visitPrimitiveType(@NotNull PsiPrimitiveType primitiveType) {
|
||||
final String name = primitiveType.getCanonicalText();
|
||||
final IdentifierImpl identifier = new IdentifierImpl(name);
|
||||
|
||||
return new IdentifierImpl(classTypeName);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String createQualifiedName(@NotNull PsiClassType classType) {
|
||||
String classTypeName = "";
|
||||
if (classType instanceof PsiClassReferenceType) {
|
||||
final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference();
|
||||
if (reference.isQualified()) {
|
||||
String result = new IdentifierImpl(reference.getReferenceName()).toKotlin();
|
||||
PsiElement qualifier = reference.getQualifier();
|
||||
while (qualifier != null) {
|
||||
final PsiJavaCodeReferenceElement p = (PsiJavaCodeReferenceElement) qualifier;
|
||||
result = new IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result; // TODO: maybe need to replace by safe call?
|
||||
qualifier = p.getQualifier();
|
||||
if (name.equals("void")) {
|
||||
myResult = new PrimitiveType(new IdentifierImpl("Unit"));
|
||||
}
|
||||
classTypeName = result;
|
||||
}
|
||||
else if (Node.PRIMITIVE_TYPES.contains(name)) {
|
||||
myResult = new PrimitiveType(new IdentifierImpl(AstUtil.upperFirstCharacter(name)));
|
||||
}
|
||||
else {
|
||||
myResult = new PrimitiveType(identifier);
|
||||
}
|
||||
return super.visitPrimitiveType(primitiveType);
|
||||
}
|
||||
return classTypeName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Type> createRawTypesForResolvedReference(@NotNull PsiClassType classType) {
|
||||
final List<Type> typeParams = new LinkedList<Type>();
|
||||
if (classType instanceof PsiClassReferenceType) {
|
||||
final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference();
|
||||
final PsiElement resolve = reference.resolve();
|
||||
if (resolve != null) {
|
||||
if (resolve instanceof PsiClass)
|
||||
//noinspection UnusedDeclaration
|
||||
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 StarProjectionType();
|
||||
|
||||
typeParams.add(boundType);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public Type visitArrayType(@NotNull PsiArrayType arrayType) {
|
||||
if (myResult == Type.EMPTY_TYPE) {
|
||||
myResult = new ArrayType(typeToType(arrayType.getComponentType()));
|
||||
}
|
||||
return super.visitArrayType(arrayType);
|
||||
}
|
||||
return typeParams;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getClassTypeName(@NotNull PsiClassType classType) {
|
||||
String canonicalTypeStr = classType.getCanonicalText();
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_OBJECT)) return "Any";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_BYTE)) return "Byte";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_CHARACTER)) return "Char";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_DOUBLE)) return "Double";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_FLOAT)) return "Float";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_INTEGER)) return "Int";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_LONG)) return "Long";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_SHORT)) return "Short";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_BOOLEAN)) return "Boolean";
|
||||
return classType.getClassName() != null ? classType.getClassName() : classType.getCanonicalText();
|
||||
}
|
||||
@Override
|
||||
public Type visitClassType(@NotNull PsiClassType classType) {
|
||||
final IdentifierImpl identifier = constructClassTypeIdentifier(classType);
|
||||
final List<Type> resolvedClassTypeParams = createRawTypesForResolvedReference(classType);
|
||||
|
||||
@Override
|
||||
public Type visitWildcardType(@NotNull PsiWildcardType wildcardType) {
|
||||
if (wildcardType.isExtends())
|
||||
myResult = new OutProjectionType(typeToType(wildcardType.getExtendsBound()));
|
||||
else if (wildcardType.isSuper())
|
||||
myResult = new InProjectionType(typeToType(wildcardType.getSuperBound()));
|
||||
else
|
||||
myResult = new StarProjectionType();
|
||||
return super.visitWildcardType(wildcardType);
|
||||
}
|
||||
if (classType.getParameterCount() == 0 && resolvedClassTypeParams.size() > 0) {
|
||||
myResult = new ClassType(identifier, resolvedClassTypeParams);
|
||||
}
|
||||
else {
|
||||
myResult = new ClassType(identifier, typesToTypeList(classType.getParameters()));
|
||||
}
|
||||
return super.visitClassType(classType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitEllipsisType(@NotNull PsiEllipsisType ellipsisType) {
|
||||
myResult = new VarArg(typeToType(ellipsisType.getComponentType()));
|
||||
return super.visitEllipsisType(ellipsisType);
|
||||
}
|
||||
@NotNull
|
||||
private static 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.hasSetting("fqn")) {
|
||||
return new IdentifierImpl(qualifiedName);
|
||||
}
|
||||
if (qualifiedName.equals(JAVA_LANG_ITERABLE)) {
|
||||
return new IdentifierImpl(JAVA_LANG_ITERABLE);
|
||||
}
|
||||
if (qualifiedName.equals(JAVA_UTIL_ITERATOR)) {
|
||||
return new IdentifierImpl(JAVA_UTIL_ITERATOR);
|
||||
}
|
||||
}
|
||||
}
|
||||
final String classTypeName = createQualifiedName(classType);
|
||||
|
||||
@Override
|
||||
public Type visitCapturedWildcardType(PsiCapturedWildcardType capturedWildcardType) {
|
||||
return super.visitCapturedWildcardType(capturedWildcardType);
|
||||
}
|
||||
if (classTypeName.isEmpty()) {
|
||||
return new IdentifierImpl(getClassTypeName(classType));
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitDisjunctionType(PsiDisjunctionType disjunctionType) {
|
||||
return super.visitDisjunctionType(disjunctionType);
|
||||
}
|
||||
return new IdentifierImpl(classTypeName);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String createQualifiedName(@NotNull PsiClassType classType) {
|
||||
String classTypeName = "";
|
||||
if (classType instanceof PsiClassReferenceType) {
|
||||
final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference();
|
||||
if (reference.isQualified()) {
|
||||
String result = new IdentifierImpl(reference.getReferenceName()).toKotlin();
|
||||
PsiElement qualifier = reference.getQualifier();
|
||||
while (qualifier != null) {
|
||||
final PsiJavaCodeReferenceElement p = (PsiJavaCodeReferenceElement) qualifier;
|
||||
result = new IdentifierImpl(p.getReferenceName()).toKotlin() + "." + result; // TODO: maybe need to replace by safe call?
|
||||
qualifier = p.getQualifier();
|
||||
}
|
||||
classTypeName = result;
|
||||
}
|
||||
}
|
||||
return classTypeName;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static List<Type> createRawTypesForResolvedReference(@NotNull PsiClassType classType) {
|
||||
final List<Type> typeParams = new LinkedList<Type>();
|
||||
if (classType instanceof PsiClassReferenceType) {
|
||||
final PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType) classType).getReference();
|
||||
final PsiElement resolve = reference.resolve();
|
||||
if (resolve != null) {
|
||||
if (resolve instanceof PsiClass)
|
||||
//noinspection UnusedDeclaration
|
||||
{
|
||||
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 StarProjectionType();
|
||||
|
||||
typeParams.add(boundType);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return typeParams;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static String getClassTypeName(@NotNull PsiClassType classType) {
|
||||
String canonicalTypeStr = classType.getCanonicalText();
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_OBJECT)) return "Any";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_BYTE)) return "Byte";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_CHARACTER)) return "Char";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_DOUBLE)) return "Double";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_FLOAT)) return "Float";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_INTEGER)) return "Int";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_LONG)) return "Long";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_SHORT)) return "Short";
|
||||
if (canonicalTypeStr.equals(JAVA_LANG_BOOLEAN)) return "Boolean";
|
||||
return classType.getClassName() != null ? classType.getClassName() : classType.getCanonicalText();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitWildcardType(@NotNull PsiWildcardType wildcardType) {
|
||||
if (wildcardType.isExtends()) {
|
||||
myResult = new OutProjectionType(typeToType(wildcardType.getExtendsBound()));
|
||||
}
|
||||
else if (wildcardType.isSuper()) {
|
||||
myResult = new InProjectionType(typeToType(wildcardType.getSuperBound()));
|
||||
}
|
||||
else {
|
||||
myResult = new StarProjectionType();
|
||||
}
|
||||
return super.visitWildcardType(wildcardType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitEllipsisType(@NotNull PsiEllipsisType ellipsisType) {
|
||||
myResult = new VarArg(typeToType(ellipsisType.getComponentType()));
|
||||
return super.visitEllipsisType(ellipsisType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitCapturedWildcardType(PsiCapturedWildcardType capturedWildcardType) {
|
||||
return super.visitCapturedWildcardType(capturedWildcardType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Type visitDisjunctionType(PsiDisjunctionType disjunctionType) {
|
||||
return super.visitDisjunctionType(disjunctionType);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -16,78 +16,79 @@ import java.util.List;
|
||||
* @author ignatov
|
||||
*/
|
||||
abstract class TestCaseBuilder {
|
||||
@NotNull
|
||||
private static final FilenameFilter emptyFilter = new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File file, String name) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
@NotNull
|
||||
public static String getTestDataPathBase() {
|
||||
return "testData";
|
||||
}
|
||||
|
||||
public static String getHomeDirectory() {
|
||||
return new File(PathManager.getResourceRoot(TestCaseBuilder.class, "/org/jetbrains/jet/TestCaseBuilder.class")).getParentFile().getParentFile().getParent();
|
||||
}
|
||||
|
||||
public interface NamedTestFactory {
|
||||
@NotNull
|
||||
Test createTest(@NotNull String dataPath, @NotNull String name);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static TestSuite suiteForDirectory(String baseDataDir, @NotNull final String dataPath, @NotNull NamedTestFactory factory) {
|
||||
return suiteForDirectory(baseDataDir, dataPath, true, emptyFilter, factory);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static TestSuite suiteForDirectory(String baseDataDir, @NotNull final String dataPath, boolean recursive, @NotNull final FilenameFilter filter, @NotNull NamedTestFactory factory) {
|
||||
TestSuite suite = new TestSuite(dataPath);
|
||||
final String extensionJava = ".jav";
|
||||
|
||||
final FilenameFilter extensionFilter = new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, @NotNull String name) {
|
||||
return name.endsWith(extensionJava);
|
||||
}
|
||||
};
|
||||
FilenameFilter resultFilter;
|
||||
if (filter != emptyFilter) {
|
||||
resultFilter = new FilenameFilter() {
|
||||
private static final FilenameFilter emptyFilter = new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File file, String s) {
|
||||
return extensionFilter.accept(file, s) && filter.accept(file, s);
|
||||
public boolean accept(File file, String name) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
} else {
|
||||
resultFilter = extensionFilter;
|
||||
}
|
||||
File dir = new File(baseDataDir + dataPath);
|
||||
FileFilter dirFilter = new FileFilter() {
|
||||
@Override
|
||||
public boolean accept(@NotNull File pathname) {
|
||||
return pathname.isDirectory();
|
||||
}
|
||||
};
|
||||
if (recursive) {
|
||||
File[] files = dir.listFiles(dirFilter);
|
||||
assert files != null : dir;
|
||||
List<File> subdirs = Arrays.asList(files);
|
||||
Collections.sort(subdirs);
|
||||
for (File subdir : subdirs) {
|
||||
suite.addTest(suiteForDirectory(baseDataDir, dataPath + "/" + subdir.getName(), recursive, filter, factory));
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static String getTestDataPathBase() {
|
||||
return "testData";
|
||||
}
|
||||
List<File> files = Arrays.asList(dir.listFiles(resultFilter));
|
||||
Collections.sort(files);
|
||||
for (File file : files) {
|
||||
String fileName = file.getName();
|
||||
assert fileName != null;
|
||||
suite.addTest(factory.createTest(dataPath, fileName.substring(0, fileName.length() - extensionJava.length())));
|
||||
|
||||
public static String getHomeDirectory() {
|
||||
return new File(PathManager.getResourceRoot(TestCaseBuilder.class, "/org/jetbrains/jet/TestCaseBuilder.class")).getParentFile().getParentFile().getParent();
|
||||
}
|
||||
|
||||
public interface NamedTestFactory {
|
||||
@NotNull
|
||||
Test createTest(@NotNull String dataPath, @NotNull String name);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static TestSuite suiteForDirectory(String baseDataDir, @NotNull final String dataPath, @NotNull NamedTestFactory factory) {
|
||||
return suiteForDirectory(baseDataDir, dataPath, true, emptyFilter, factory);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
private static TestSuite suiteForDirectory(String baseDataDir, @NotNull final String dataPath, boolean recursive, @NotNull final FilenameFilter filter, @NotNull NamedTestFactory factory) {
|
||||
TestSuite suite = new TestSuite(dataPath);
|
||||
final String extensionJava = ".jav";
|
||||
|
||||
final FilenameFilter extensionFilter = new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File dir, @NotNull String name) {
|
||||
return name.endsWith(extensionJava);
|
||||
}
|
||||
};
|
||||
FilenameFilter resultFilter;
|
||||
if (filter != emptyFilter) {
|
||||
resultFilter = new FilenameFilter() {
|
||||
@Override
|
||||
public boolean accept(File file, String s) {
|
||||
return extensionFilter.accept(file, s) && filter.accept(file, s);
|
||||
}
|
||||
};
|
||||
}
|
||||
else {
|
||||
resultFilter = extensionFilter;
|
||||
}
|
||||
File dir = new File(baseDataDir + dataPath);
|
||||
FileFilter dirFilter = new FileFilter() {
|
||||
@Override
|
||||
public boolean accept(@NotNull File pathname) {
|
||||
return pathname.isDirectory();
|
||||
}
|
||||
};
|
||||
if (recursive) {
|
||||
File[] files = dir.listFiles(dirFilter);
|
||||
assert files != null : dir;
|
||||
List<File> subdirs = Arrays.asList(files);
|
||||
Collections.sort(subdirs);
|
||||
for (File subdir : subdirs) {
|
||||
suite.addTest(suiteForDirectory(baseDataDir, dataPath + "/" + subdir.getName(), recursive, filter, factory));
|
||||
}
|
||||
}
|
||||
List<File> files = Arrays.asList(dir.listFiles(resultFilter));
|
||||
Collections.sort(files);
|
||||
for (File file : files) {
|
||||
String fileName = file.getName();
|
||||
assert fileName != null;
|
||||
suite.addTest(factory.createTest(dataPath, fileName.substring(0, fileName.length() - extensionJava.length())));
|
||||
}
|
||||
return suite;
|
||||
}
|
||||
return suite;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user