From 6c5bfc3b8e6cd3be232d67c3e586d0e1647c8a6c Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 27 Jan 2012 17:33:00 +0400 Subject: [PATCH] Reformat code to use 4 spaces indent --- j2k/src/org/jetbrains/jet/j2k/Converter.java | 1414 +++++++++-------- .../org/jetbrains/jet/j2k/ConverterUtil.java | 188 +-- .../jet/j2k/JavaToKotlinTranslator.java | 327 ++-- .../SetupJavaCoreEnvironmentException.java | 4 +- .../jetbrains/jet/j2k/ast/AnonymousClass.java | 30 +- .../jet/j2k/ast/ArrayAccessExpression.java | 22 +- .../j2k/ast/ArrayInitializerExpression.java | 110 +- .../org/jetbrains/jet/j2k/ast/ArrayType.java | 39 +- .../ArrayWithoutInitializationExpression.java | 73 +- .../jet/j2k/ast/AssertStatement.java | 24 +- .../jet/j2k/ast/AssignmentExpression.java | 48 +- .../jet/j2k/ast/BinaryExpression.java | 38 +- j2k/src/org/jetbrains/jet/j2k/ast/Block.java | 63 +- .../jetbrains/jet/j2k/ast/BreakStatement.java | 37 +- .../jet/j2k/ast/CallChainExpression.java | 59 +- .../jetbrains/jet/j2k/ast/CaseContainer.java | 31 +- .../jetbrains/jet/j2k/ast/CatchStatement.java | 22 +- j2k/src/org/jetbrains/jet/j2k/ast/Class.java | 428 ++--- .../j2k/ast/ClassObjectAccessExpression.java | 18 +- .../org/jetbrains/jet/j2k/ast/ClassType.java | 46 +- .../jetbrains/jet/j2k/ast/Constructor.java | 42 +- .../jet/j2k/ast/ContinueStatement.java | 37 +- .../jet/j2k/ast/DeclarationStatement.java | 48 +- .../j2k/ast/DefaultSwitchLabelStatement.java | 10 +- .../jet/j2k/ast/DoWhileStatement.java | 20 +- .../j2k/ast/DummyMethodCallExpression.java | 26 +- .../jet/j2k/ast/DummyStringExpression.java | 18 +- .../org/jetbrains/jet/j2k/ast/Element.java | 36 +- j2k/src/org/jetbrains/jet/j2k/ast/Enum.java | 46 +- .../jetbrains/jet/j2k/ast/EnumConstant.java | 21 +- .../org/jetbrains/jet/j2k/ast/Expression.java | 36 +- .../jetbrains/jet/j2k/ast/ExpressionList.java | 24 +- .../jet/j2k/ast/ExpressionListStatement.java | 18 +- j2k/src/org/jetbrains/jet/j2k/ast/Field.java | 97 +- j2k/src/org/jetbrains/jet/j2k/ast/File.java | 39 +- .../jet/j2k/ast/ForeachStatement.java | 28 +- .../j2k/ast/ForeachWithRangeStatement.java | 36 +- .../org/jetbrains/jet/j2k/ast/Function.java | 164 +- .../org/jetbrains/jet/j2k/ast/IMember.java | 4 +- j2k/src/org/jetbrains/jet/j2k/ast/INode.java | 14 +- .../org/jetbrains/jet/j2k/ast/Identifier.java | 8 +- .../jetbrains/jet/j2k/ast/IdentifierImpl.java | 83 +- .../jetbrains/jet/j2k/ast/IfStatement.java | 37 +- j2k/src/org/jetbrains/jet/j2k/ast/Import.java | 24 +- .../jet/j2k/ast/InProjectionType.java | 18 +- .../jetbrains/jet/j2k/ast/Initializer.java | 20 +- .../org/jetbrains/jet/j2k/ast/IsOperator.java | 22 +- .../jetbrains/jet/j2k/ast/LabelStatement.java | 22 +- .../jet/j2k/ast/LiteralExpression.java | 28 +- .../jetbrains/jet/j2k/ast/LocalVariable.java | 43 +- j2k/src/org/jetbrains/jet/j2k/ast/Member.java | 33 +- .../jet/j2k/ast/MethodCallExpression.java | 54 +- .../org/jetbrains/jet/j2k/ast/Modifier.java | 40 +- .../jet/j2k/ast/NewClassExpression.java | 61 +- j2k/src/org/jetbrains/jet/j2k/ast/Node.java | 84 +- .../jet/j2k/ast/OutProjectionType.java | 18 +- .../org/jetbrains/jet/j2k/ast/Parameter.java | 38 +- .../jetbrains/jet/j2k/ast/ParameterList.java | 18 +- .../jet/j2k/ast/ParenthesizedExpression.java | 18 +- .../jet/j2k/ast/PolyadicExpression.java | 30 +- .../jet/j2k/ast/PostfixOperator.java | 22 +- .../jetbrains/jet/j2k/ast/PrefixOperator.java | 22 +- .../jetbrains/jet/j2k/ast/PrimitiveType.java | 26 +- .../jet/j2k/ast/ReferenceElement.java | 28 +- .../jet/j2k/ast/ReturnStatement.java | 28 +- .../jet/j2k/ast/StarProjectionType.java | 20 +- .../org/jetbrains/jet/j2k/ast/Statement.java | 22 +- .../jet/j2k/ast/SuperExpression.java | 23 +- .../jet/j2k/ast/SureCallChainExpression.java | 30 +- .../jet/j2k/ast/SwitchContainer.java | 26 +- .../jet/j2k/ast/SwitchLabelStatement.java | 18 +- .../jet/j2k/ast/SynchronizedStatement.java | 22 +- .../jetbrains/jet/j2k/ast/ThisExpression.java | 23 +- .../jetbrains/jet/j2k/ast/ThrowStatement.java | 18 +- j2k/src/org/jetbrains/jet/j2k/ast/Trait.java | 24 +- .../jetbrains/jet/j2k/ast/TryStatement.java | 32 +- j2k/src/org/jetbrains/jet/j2k/ast/Type.java | 66 +- .../jet/j2k/ast/TypeCastExpression.java | 22 +- .../jetbrains/jet/j2k/ast/TypeElement.java | 18 +- .../jetbrains/jet/j2k/ast/TypeParameter.java | 46 +- j2k/src/org/jetbrains/jet/j2k/ast/VarArg.java | 28 +- .../jetbrains/jet/j2k/ast/WhileStatement.java | 24 +- .../org/jetbrains/jet/j2k/util/AstUtil.java | 151 +- .../jet/j2k/visitors/ClassVisitor.java | 26 +- .../jet/j2k/visitors/Dispatcher.java | 20 +- .../jet/j2k/visitors/ElementVisitor.java | 145 +- .../jet/j2k/visitors/ExpressionVisitor.java | 855 +++++----- ...ssionVisitorForDirectObjectInheritors.java | 61 +- .../jet/j2k/visitors/StatementVisitor.java | 657 ++++---- .../jet/j2k/visitors/SuperVisitor.java | 53 +- .../jet/j2k/visitors/ThisVisitor.java | 46 +- .../jet/j2k/visitors/TypeVisitor.java | 300 ++-- .../jetbrains/jet/j2k/TestCaseBuilder.java | 137 +- 93 files changed, 3856 insertions(+), 3667 deletions(-) diff --git a/j2k/src/org/jetbrains/jet/j2k/Converter.java b/j2k/src/org/jetbrains/jet/j2k/Converter.java index 3d7a86624bb..d0c5eea6e8c 100644 --- a/j2k/src/org/jetbrains/jet/j2k/Converter.java +++ b/j2k/src/org/jetbrains/jet/j2k/Converter.java @@ -19,723 +19,769 @@ import static org.jetbrains.jet.j2k.visitors.TypeVisitor.*; * @author ignatov */ public class Converter { - @NotNull - final static Set NOT_NULL_ANNOTATIONS = new HashSet() { - { - add("org.jetbrains.annotations.NotNull"); - add("com.sun.istack.internal.NotNull"); - add("javax.annotation.Nonnull"); - } - }; - @NotNull - private static Set ourClassIdentifiers = new HashSet(); - @NotNull - private static final Dispatcher ourDispatcher = new Dispatcher(); - @Nullable - private static PsiType ourMethodReturnType = null; + @NotNull + final static Set NOT_NULL_ANNOTATIONS = new HashSet() { + { + add("org.jetbrains.annotations.NotNull"); + add("com.sun.istack.internal.NotNull"); + add("javax.annotation.Nonnull"); + } + }; + @NotNull + private static Set ourClassIdentifiers = new HashSet(); + @NotNull + private static final Dispatcher ourDispatcher = new Dispatcher(); + @Nullable + private static PsiType ourMethodReturnType = null; - @NotNull - private static Set settings = new HashSet(); + @NotNull + private static Set settings = new HashSet(); - private Converter() { - } - - public static boolean addSetting(@NotNull String value) { - return settings.add(value); - } - - public static boolean hasSetting(@NotNull String value) { - return settings.contains(value); - } - - public static void setClassIdentifiers(@NotNull Set identifiers) { - ourClassIdentifiers = identifiers; - } - - @NotNull - public static Set getClassIdentifiers() { - return new HashSet(ourClassIdentifiers); - } - - @Nullable - public static PsiType getMethodReturnType() { - return ourMethodReturnType; - } - - public static void clearClassIdentifiers() { - ourClassIdentifiers.clear(); - } - - @NotNull - public static String elementToKotlin(@NotNull PsiElement element) { - if (element instanceof PsiJavaFile) - return fileToFile((PsiJavaFile) element).toKotlin(); - - if (element instanceof PsiClass) - return classToClass((PsiClass) element).toKotlin(); - - if (element instanceof PsiMethod) - return methodToFunction((PsiMethod) element).toKotlin(); - - if (element instanceof PsiField) { - PsiField field = (PsiField) element; - return fieldToField(field, field.getContainingClass()).toKotlin(); + private Converter() { } - if (element instanceof PsiStatement) - return statementToStatement((PsiStatement) element).toKotlin(); - - if (element instanceof PsiExpression) - return expressionToExpression((PsiExpression) element).toKotlin(); - - return ""; - } - - @NotNull - public static File fileToFile(@NotNull PsiJavaFile javaFile) { - return fileToFile(javaFile, Collections.emptyList()); - } - - @NotNull - public static File fileToFileWithCompatibilityImport(@NotNull PsiJavaFile javaFile) { - return fileToFile(javaFile, Collections.singletonList("std.compatibility.*")); - } - - @NotNull - private static File fileToFile(PsiJavaFile javaFile, List additionalImports) { - final PsiImportList importList = javaFile.getImportList(); - List imports = importList == null ? Collections.emptyList() : importsToImportList(importList.getAllImportStatements()); - for (String i : additionalImports) - imports.add(new Import(i)); - return new File(quoteKeywords(javaFile.getPackageName()), imports, classesToClassList(javaFile.getClasses()), createMainFunction(javaFile)); - } - - @NotNull - private static String quoteKeywords(@NotNull String packageName) { - List result = new LinkedList(); - for (String part : packageName.split("\\.")) - result.add(new IdentifierImpl(part).toKotlin()); - return AstUtil.join(result, "."); - } - - @NotNull - private static List classesToClassList(@NotNull PsiClass[] classes) { - List result = new LinkedList(); - for (PsiClass t : classes) result.add(classToClass(t)); - return result; - } - - @NotNull - public static AnonymousClass anonymousClassToAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) { - return new AnonymousClass(getMembers(anonymousClass)); - } - - @NotNull - private static List getMembers(@NotNull PsiClass psiClass) { - List members = new LinkedList(); - for (PsiElement e : psiClass.getChildren()) { - if (e instanceof PsiMethod) members.add(methodToFunction((PsiMethod) e, true)); - else if (e instanceof PsiField) members.add(fieldToField((PsiField) e, psiClass)); - else if (e instanceof PsiClass) members.add(classToClass((PsiClass) e)); - else if (e instanceof PsiClassInitializer) members.add(initializerToInitializer((PsiClassInitializer) e)); - else if (e instanceof PsiMember) System.out.println(e.getClass() + " " + e.getText()); + public static boolean addSetting(@NotNull String value) { + return settings.add(value); } - return members; - } - @NotNull - private static List getFinalOrWithEmptyInitializer(@NotNull List fields) { - List result = new LinkedList(); - for (Field f : fields) - if (f.isVal() || f.getInitializer().toKotlin().isEmpty()) - result.add(f); - return result; - } - - @NotNull - private static List createParametersFromFields(@NotNull List fields) { - List result = new LinkedList(); - for (Field f : fields) - result.add(new Parameter(new IdentifierImpl("_" + f.getIdentifier().getName()), f.getType())); - return result; - } - - @NotNull - private static List createInitStatementsFromFields(@NotNull List fields) { - List result = new LinkedList(); - for (Field f : fields) { - final String identifierToKotlin = f.getIdentifier().toKotlin(); - result.add(new DummyStringExpression(identifierToKotlin + " = " + "_" + identifierToKotlin)); + public static boolean hasSetting(@NotNull String value) { + return settings.contains(value); } - return result; - } - @NotNull - private static String createPrimaryConstructorInvocation(@NotNull String s, @NotNull List fields, @NotNull Map initializers) { - List result = new LinkedList(); - for (Field f : fields) { - final String id = f.getIdentifier().toKotlin(); - result.add(initializers.get(id)); + public static void setClassIdentifiers(@NotNull Set identifiers) { + ourClassIdentifiers = identifiers; } - return s + "(" + AstUtil.join(result, ", ") + ")"; - } - @NotNull - private static Class classToClass(@NotNull PsiClass psiClass) { - final Set modifiers = modifiersListToModifiersSet(psiClass.getModifierList()); - final List fields = fieldsToFieldList(psiClass.getFields(), psiClass); - final List typeParameters = elementsToElementList(psiClass.getTypeParameters()); - final List implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes()); - final List extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes()); - final IdentifierImpl name = new IdentifierImpl(psiClass.getName()); - final List baseClassParams = new LinkedList(); + @NotNull + public static Set getClassIdentifiers() { + return new HashSet(ourClassIdentifiers); + } - List members = getMembers(psiClass); + @Nullable + public static PsiType getMethodReturnType() { + return ourMethodReturnType; + } - // we try to find super() call and generate class declaration like that: class A(name: String, i : Int) : Base(name) - final SuperVisitor visitor = new SuperVisitor(); - psiClass.accept(visitor); - final HashSet resolvedSuperCallParameters = visitor.getResolvedSuperCallParameters(); - if (resolvedSuperCallParameters.size() == 1) - baseClassParams.addAll( - expressionsToExpressionList( - resolvedSuperCallParameters.toArray(new PsiExpressionList[1])[0].getExpressions() - ) - ); + public static void clearClassIdentifiers() { + ourClassIdentifiers.clear(); + } - // we create primary constructor from all non final fields and fields without initializers - if (!psiClass.isEnum() && !psiClass.isInterface() && psiClass.getConstructors().length > 1 && getPrimaryConstructorForThisCase(psiClass) == null) { - final List finalOrWithEmptyInitializer = getFinalOrWithEmptyInitializer(fields); - final Map initializers = new HashMap(); + @NotNull + public static String elementToKotlin(@NotNull PsiElement element) { + if (element instanceof PsiJavaFile) { + return fileToFile((PsiJavaFile) element).toKotlin(); + } - for (final Member m : members) { - // and modify secondaries - if (m.getKind() == INode.Kind.CONSTRUCTOR) { - Function f = (Function) m; - if (!((Constructor) f).isPrimary()) { - for (Field fo : finalOrWithEmptyInitializer) { - String init = getDefaultInitializer(fo); - initializers.put(fo.getIdentifier().toKotlin(), init); + if (element instanceof PsiClass) { + return classToClass((PsiClass) element).toKotlin(); + } + + if (element instanceof PsiMethod) { + return methodToFunction((PsiMethod) element).toKotlin(); + } + + if (element instanceof PsiField) { + PsiField field = (PsiField) element; + return fieldToField(field, field.getContainingClass()).toKotlin(); + } + + if (element instanceof PsiStatement) { + return statementToStatement((PsiStatement) element).toKotlin(); + } + + if (element instanceof PsiExpression) { + return expressionToExpression((PsiExpression) element).toKotlin(); + } + + return ""; + } + + @NotNull + public static File fileToFile(@NotNull PsiJavaFile javaFile) { + return fileToFile(javaFile, Collections.emptyList()); + } + + @NotNull + public static File fileToFileWithCompatibilityImport(@NotNull PsiJavaFile javaFile) { + return fileToFile(javaFile, Collections.singletonList("std.compatibility.*")); + } + + @NotNull + private static File fileToFile(PsiJavaFile javaFile, List additionalImports) { + final PsiImportList importList = javaFile.getImportList(); + List imports = importList == null + ? Collections.emptyList() + : importsToImportList(importList.getAllImportStatements()); + for (String i : additionalImports) + imports.add(new Import(i)); + return new File(quoteKeywords(javaFile.getPackageName()), imports, classesToClassList(javaFile.getClasses()), createMainFunction(javaFile)); + } + + @NotNull + private static String quoteKeywords(@NotNull String packageName) { + List result = new LinkedList(); + for (String part : packageName.split("\\.")) + result.add(new IdentifierImpl(part).toKotlin()); + return AstUtil.join(result, "."); + } + + @NotNull + private static List classesToClassList(@NotNull PsiClass[] classes) { + List result = new LinkedList(); + for (PsiClass t : classes) result.add(classToClass(t)); + return result; + } + + @NotNull + public static AnonymousClass anonymousClassToAnonymousClass(@NotNull PsiAnonymousClass anonymousClass) { + return new AnonymousClass(getMembers(anonymousClass)); + } + + @NotNull + private static List getMembers(@NotNull PsiClass psiClass) { + List members = new LinkedList(); + for (PsiElement e : psiClass.getChildren()) { + if (e instanceof PsiMethod) { + members.add(methodToFunction((PsiMethod) e, true)); } + else if (e instanceof PsiField) { + members.add(fieldToField((PsiField) e, psiClass)); + } + else if (e instanceof PsiClass) { + members.add(classToClass((PsiClass) e)); + } + else if (e instanceof PsiClassInitializer) { + members.add(initializerToInitializer((PsiClassInitializer) e)); + } + else if (e instanceof PsiMember) System.out.println(e.getClass() + " " + e.getText()); + } + return members; + } - final List newStatements = new LinkedList(); + @NotNull + private static List getFinalOrWithEmptyInitializer(@NotNull List fields) { + List result = new LinkedList(); + for (Field f : fields) + if (f.isVal() || f.getInitializer().toKotlin().isEmpty()) { + result.add(f); + } + return result; + } - for (Statement s : f.getBlock().getStatements()) { - boolean isRemoved = false; + @NotNull + private static List createParametersFromFields(@NotNull List fields) { + List result = new LinkedList(); + for (Field f : fields) + result.add(new Parameter(new IdentifierImpl("_" + f.getIdentifier().getName()), f.getType())); + return result; + } - if (s.getKind() == INode.Kind.ASSIGNMENT_EXPRESSION) { - final AssignmentExpression assignmentExpression = (AssignmentExpression) s; - if (assignmentExpression.getLeft().getKind() == INode.Kind.CALL_CHAIN) { - for (Field fo : finalOrWithEmptyInitializer) { - final String id = fo.getIdentifier().toKotlin(); - if (((CallChainExpression) assignmentExpression.getLeft()).getIdentifier().toKotlin().endsWith("." + id)) { - initializers.put(id, assignmentExpression.getRight().toKotlin()); - isRemoved = true; + @NotNull + private static List createInitStatementsFromFields(@NotNull List fields) { + List result = new LinkedList(); + for (Field f : fields) { + final String identifierToKotlin = f.getIdentifier().toKotlin(); + result.add(new DummyStringExpression(identifierToKotlin + " = " + "_" + identifierToKotlin)); + } + return result; + } + + @NotNull + private static String createPrimaryConstructorInvocation(@NotNull String s, @NotNull List fields, @NotNull Map initializers) { + List result = new LinkedList(); + for (Field f : fields) { + final String id = f.getIdentifier().toKotlin(); + result.add(initializers.get(id)); + } + return s + "(" + AstUtil.join(result, ", ") + ")"; + } + + @NotNull + private static Class classToClass(@NotNull PsiClass psiClass) { + final Set modifiers = modifiersListToModifiersSet(psiClass.getModifierList()); + final List fields = fieldsToFieldList(psiClass.getFields(), psiClass); + final List typeParameters = elementsToElementList(psiClass.getTypeParameters()); + final List implementsTypes = typesToNotNullableTypeList(psiClass.getImplementsListTypes()); + final List extendsTypes = typesToNotNullableTypeList(psiClass.getExtendsListTypes()); + final IdentifierImpl name = new IdentifierImpl(psiClass.getName()); + final List baseClassParams = new LinkedList(); + + List members = getMembers(psiClass); + + // we try to find super() call and generate class declaration like that: class A(name: String, i : Int) : Base(name) + final SuperVisitor visitor = new SuperVisitor(); + psiClass.accept(visitor); + final HashSet resolvedSuperCallParameters = visitor.getResolvedSuperCallParameters(); + if (resolvedSuperCallParameters.size() == 1) { + baseClassParams.addAll( + expressionsToExpressionList( + resolvedSuperCallParameters.toArray(new PsiExpressionList[1])[0].getExpressions() + ) + ); + } + + // we create primary constructor from all non final fields and fields without initializers + if (!psiClass.isEnum() && !psiClass.isInterface() && psiClass.getConstructors().length > 1 && getPrimaryConstructorForThisCase(psiClass) == null) { + final List finalOrWithEmptyInitializer = getFinalOrWithEmptyInitializer(fields); + final Map initializers = new HashMap(); + + for (final Member m : members) { + // and modify secondaries + if (m.getKind() == INode.Kind.CONSTRUCTOR) { + Function f = (Function) m; + if (!((Constructor) f).isPrimary()) { + for (Field fo : finalOrWithEmptyInitializer) { + String init = getDefaultInitializer(fo); + initializers.put(fo.getIdentifier().toKotlin(), init); + } + + final List newStatements = new LinkedList(); + + for (Statement s : f.getBlock().getStatements()) { + boolean isRemoved = false; + + if (s.getKind() == INode.Kind.ASSIGNMENT_EXPRESSION) { + final AssignmentExpression assignmentExpression = (AssignmentExpression) s; + if (assignmentExpression.getLeft().getKind() == INode.Kind.CALL_CHAIN) { + for (Field fo : finalOrWithEmptyInitializer) { + final String id = fo.getIdentifier().toKotlin(); + if (((CallChainExpression) assignmentExpression.getLeft()).getIdentifier().toKotlin().endsWith("." + id)) { + initializers.put(id, assignmentExpression.getRight().toKotlin()); + isRemoved = true; + } + } + } + } + if (!isRemoved) { + newStatements.add(s); + } + } + + newStatements.add( + 0, + new DummyStringExpression( + "val __ = " + createPrimaryConstructorInvocation( + name.toKotlin(), + finalOrWithEmptyInitializer, + initializers))); + + f.setBlock(new Block(newStatements)); } - } } - } - if (!isRemoved) { - newStatements.add(s); - } } - newStatements.add( - 0, - new DummyStringExpression( - "val __ = " + createPrimaryConstructorInvocation( - name.toKotlin(), - finalOrWithEmptyInitializer, - initializers))); - - f.setBlock(new Block(newStatements)); - } + members.add( + new Constructor( + Identifier.EMPTY_IDENTIFIER, + Collections.emptySet(), + new ClassType(name), + Collections.emptyList(), + new ParameterList(createParametersFromFields(finalOrWithEmptyInitializer)), + new Block(createInitStatementsFromFields(finalOrWithEmptyInitializer)), + true + ) + ); } - } - members.add( - new Constructor( - Identifier.EMPTY_IDENTIFIER, - Collections.emptySet(), - new ClassType(name), - Collections.emptyList(), - new ParameterList(createParametersFromFields(finalOrWithEmptyInitializer)), - new Block(createInitStatementsFromFields(finalOrWithEmptyInitializer)), - true - ) - ); - } - - if (psiClass.isInterface()) - return new Trait(name, modifiers, typeParameters, extendsTypes, Collections.emptyList(), implementsTypes, members); - if (psiClass.isEnum()) - return new Enum(name, modifiers, typeParameters, Collections.emptyList(), Collections.emptyList(), implementsTypes, members); - return new Class(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members); - } - - @NotNull - private static Initializer initializerToInitializer(@NotNull PsiClassInitializer i) { - return new Initializer( - blockToBlock(i.getBody(), true), - modifiersListToModifiersSet(i.getModifierList()) - ); - } - - @NotNull - public static String getDefaultInitializer(@NotNull Field f) { - if (f.getType().isNullable()) - return "null"; - else { - final String typeToKotlin = f.getType().toKotlin(); - if (typeToKotlin.equals("Boolean")) return "false"; - if (typeToKotlin.equals("Char")) return "' '"; - if (typeToKotlin.equals("Double")) return "0.dbl"; - if (typeToKotlin.equals("Float")) return "0.flt"; - return "0"; - } - } - - @NotNull - private static List fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) { - List result = new LinkedList(); - for (PsiField f : fields) result.add(fieldToField(f, psiClass)); - return result; - } - - @NotNull - private static Field fieldToField(@NotNull PsiField field, PsiClass psiClass) { - Set modifiers = modifiersListToModifiersSet(field.getModifierList()); - if (field instanceof PsiEnumConstant) // TODO: remove instanceof - return new EnumConstant( - new IdentifierImpl(field.getName()), // TODO - modifiers, - typeToType(field.getType()), - elementToElement(((PsiEnumConstant) field).getArgumentList()) - ); - return new Field( - new IdentifierImpl(field.getName()), // TODO - modifiers, - typeToType(field.getType()), - createSureCallOnlyForChain(field.getInitializer(), field.getType()), // TODO: add modifiers - countWritingAccesses(field, psiClass) - ); - } - - @Nullable - private static PsiMethod getPrimaryConstructorForThisCase(@NotNull PsiClass psiClass) { - ThisVisitor tv = new ThisVisitor(); - psiClass.accept(tv); - return tv.getPrimaryConstructor(); - } - - public static boolean isConstructorPrimary(@NotNull PsiMethod constructor) { - if (constructor.getParent() instanceof PsiClass) { - final PsiClass parent = (PsiClass) constructor.getParent(); - if (parent.getConstructors().length == 1) - return true; - else { - PsiMethod c = getPrimaryConstructorForThisCase(parent); // TODO: move up to classToClass() method - if (c != null && c.hashCode() == constructor.hashCode()) - return true; - } - } - return false; - } - - @NotNull - private static List removeEmpty(@NotNull List statements) { - List result = new LinkedList(); - for (Statement s : statements) - if (s != Statement.EMPTY_STATEMENT && s != Expression.EMPTY_EXPRESSION) - result.add(s); - return result; - } - - @NotNull - private static Function methodToFunction(@NotNull PsiMethod method) { - return methodToFunction(method, true); - } - - @NotNull - private static Function methodToFunction(@NotNull PsiMethod method, boolean notEmpty) { - if (isOverrideObjectDirect(method)) - ourDispatcher.setExpressionVisitor(new ExpressionVisitorForDirectObjectInheritors()); - else - ourDispatcher.setExpressionVisitor(new ExpressionVisitor()); - - ourMethodReturnType = method.getReturnType(); - - final IdentifierImpl identifier = new IdentifierImpl(method.getName()); - final Type returnType = typeToType(method.getReturnType(), ConverterUtil.isAnnotatedAsNotNull(method.getModifierList())); - final Block body = hasSetting("declarations-only") ? Block.EMPTY_BLOCK : blockToBlock(method.getBody(), notEmpty); // #TODO - final Element params = createFunctionParameters(method); - final List typeParameters = elementsToElementList(method.getTypeParameters()); - - final Set modifiers = modifiersListToModifiersSet(method.getModifierList()); - if (isOverrideAnyMethodExceptMethodsFromObject(method)) - modifiers.add(Modifier.OVERRIDE); - if (method.getParent() instanceof PsiClass && ((PsiClass) method.getParent()).isInterface()) - modifiers.remove(Modifier.ABSTRACT); - if (isNotOpenMethod(method)) - modifiers.add(Modifier.NOT_OPEN); - - if (method.isConstructor()) { // TODO: simplify - boolean isPrimary = isConstructorPrimary(method); - return new Constructor( - identifier, - modifiers, - returnType, - typeParameters, - params, - new Block(removeEmpty(body.getStatements()), false), - isPrimary - ); - } - return new Function( - identifier, - modifiers, - returnType, - typeParameters, - params, - body - ); - } - - @NotNull - private static ParameterList createFunctionParameters(@NotNull PsiMethod method) { - List result = new LinkedList(); - for (PsiParameter parameter : method.getParameterList().getParameters()) { - result.add(new Parameter( - new IdentifierImpl(parameter.getName()), - typeToType(parameter.getType(), ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())), - ConverterUtil.isReadOnly(parameter, method.getBody()) - )); - } - return new ParameterList(result); - } - - private static boolean isNotOpenMethod(@NotNull final PsiMethod method) { - if (method.getParent() instanceof PsiClass) { - final PsiModifierList parentModifierList = ((PsiClass) method.getParent()).getModifierList(); - if ((parentModifierList != null && parentModifierList.hasExplicitModifier(Modifier.FINAL)) || ((PsiClass) method.getParent()).isEnum()) - return true; - } - return false; - } - - private static boolean isOverrideAnyMethodExceptMethodsFromObject(@NotNull PsiMethod method) { - boolean counter = normalCase(method); - if (counter) - return true; - if (isInheritFromObject(method)) - return caseForObject(method); - return false; - } - - private static boolean caseForObject(@NotNull PsiMethod method) { - PsiClass containing = method.getContainingClass(); - if (containing != null) { - for (PsiClassType s : containing.getSuperTypes()) { - String canonicalText = s.getCanonicalText(); - if (!canonicalText.equals(JAVA_LANG_OBJECT) && !getClassIdentifiers().contains(canonicalText)) { - return true; + if (psiClass.isInterface()) { + return new Trait(name, modifiers, typeParameters, extendsTypes, Collections.emptyList(), implementsTypes, members); } - } - } - return false; - } - - private static boolean normalCase(@NotNull PsiMethod method) { - int counter = 0; - for (HierarchicalMethodSignature s : method.getHierarchicalMethodSignature().getSuperSignatures()) { - PsiClass containingClass = s.getMethod().getContainingClass(); - String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; - if (qualifiedName != null && !qualifiedName.equals(JAVA_LANG_OBJECT)) - counter++; - } - return counter > 0; - } - - private static boolean isInheritFromObject(@NotNull PsiMethod method) { - List superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures(); - for (HierarchicalMethodSignature s : superSignatures) { - PsiClass containingClass = s.getMethod().getContainingClass(); - String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; - if (qualifiedName != null && qualifiedName.equals(JAVA_LANG_OBJECT)) - return true; - } - return false; - } - - private static boolean isOverrideObjectDirect(@NotNull final PsiMethod method) { - List superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures(); - if (superSignatures.size() == 1) { - final PsiClass containingClass = superSignatures.get(0).getMethod().getContainingClass(); - final String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; - if (qualifiedName != null && qualifiedName.equals(JAVA_LANG_OBJECT)) - return true; - } - return false; - } - - @NotNull - public static Block blockToBlock(@Nullable PsiCodeBlock block, boolean notEmpty) { - if (block == null) return Block.EMPTY_BLOCK; - return new Block(statementsToStatementList(block.getStatements()), notEmpty); - } - - @NotNull - public static Block blockToBlock(@Nullable PsiCodeBlock block) { - return blockToBlock(block, true); - } - - @NotNull - public static List statementsToStatementList(@NotNull PsiStatement[] statements) { - List result = new LinkedList(); - for (PsiStatement t : statements) result.add(statementToStatement(t)); - return result; - } - - @NotNull - public static List statementsToStatementList(@NotNull List statements) { - List result = new LinkedList(); - for (PsiStatement t : statements) result.add(statementToStatement(t)); - return result; - } - - @NotNull - public static Statement statementToStatement(@Nullable PsiStatement s) { - if (s == null) return Statement.EMPTY_STATEMENT; - final StatementVisitor statementVisitor = new StatementVisitor(); - s.accept(statementVisitor); - return statementVisitor.getResult(); - } - - @NotNull - public static List expressionsToExpressionList(@NotNull PsiExpression[] expressions) { - List result = new LinkedList(); - for (PsiExpression e : expressions) result.add(expressionToExpression(e)); - return result; - } - - @NotNull - public static Expression expressionToExpression(@Nullable PsiExpression e) { - if (e == null) return Expression.EMPTY_EXPRESSION; - final ExpressionVisitor expressionVisitor = ourDispatcher.getExpressionVisitor(); - e.accept(expressionVisitor); - return expressionVisitor.getResult(); - } - - @NotNull - public static Element elementToElement(@Nullable PsiElement e) { - if (e == null) return Element.EMPTY_ELEMENT; - final ElementVisitor elementVisitor = new ElementVisitor(); - e.accept(elementVisitor); - return elementVisitor.getResult(); - } - - @NotNull - public static List elementsToElementList(@NotNull PsiElement[] elements) { - List result = new LinkedList(); - for (PsiElement e : elements) result.add(elementToElement(e)); - return result; - } - - @NotNull - public static Type typeToType(@Nullable PsiType type) { - if (type == null) return Type.EMPTY_TYPE; - TypeVisitor typeVisitor = new TypeVisitor(); - type.accept(typeVisitor); - return typeVisitor.getResult(); - } - - @NotNull - public static List typesToTypeList(@NotNull PsiType[] types) { - List result = new LinkedList(); - for (PsiType t : types) result.add(typeToType(t)); - return result; - } - - @NotNull - public static Type typeToType(PsiType type, boolean notNull) { - Type result = typeToType(type); - if (notNull) - result.convertedToNotNull(); - return result; - } - - @NotNull - private static List typesToNotNullableTypeList(@NotNull PsiType[] types) { - List result = new LinkedList(typesToTypeList(types)); - for (Type p : result) p.convertedToNotNull(); - return result; - } - - @NotNull - private static List importsToImportList(@NotNull PsiImportStatementBase[] imports) { - List result = new LinkedList(); - for (PsiImportStatementBase i : imports) { - Import anImport = importToImport(i); - String name = anImport.getName(); - if (!name.isEmpty() && !NOT_NULL_ANNOTATIONS.contains(name)) - result.add(anImport); - } - return result; - } - - @NotNull - private static Import importToImport(@NotNull PsiImportStatementBase i) { - final PsiJavaCodeReferenceElement reference = i.getImportReference(); - if (reference != null) - return new Import(quoteKeywords(reference.getQualifiedName()) + (i.isOnDemand() ? ".*" : "")); - return new Import(""); - } - - @NotNull - public static List parametersToParameterList(@NotNull PsiParameter[] parameters) { - List result = new LinkedList(); - for (PsiParameter t : parameters) result.add(parameterToParameter(t)); - return result; - } - - @NotNull - public static Parameter parameterToParameter(@NotNull PsiParameter parameter) { - return new Parameter( - new IdentifierImpl(parameter.getName()), - typeToType(parameter.getType(), ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())) - ); - } - - @NotNull - public static Identifier identifierToIdentifier(@Nullable PsiIdentifier identifier) { - if (identifier == null) return Identifier.EMPTY_IDENTIFIER; - return new IdentifierImpl(identifier.getText()); - } - - @NotNull - public static Set modifiersListToModifiersSet(@Nullable PsiModifierList modifierList) { - HashSet modifiersSet = new HashSet(); - if (modifierList != null) { - if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT)) modifiersSet.add(Modifier.ABSTRACT); - if (modifierList.hasModifierProperty(PsiModifier.FINAL)) modifiersSet.add(Modifier.FINAL); - if (modifierList.hasModifierProperty(PsiModifier.STATIC)) modifiersSet.add(Modifier.STATIC); - if (modifierList.hasExplicitModifier(PsiModifier.PUBLIC)) modifiersSet.add(Modifier.PUBLIC); - if (modifierList.hasExplicitModifier(PsiModifier.PROTECTED)) modifiersSet.add(Modifier.PROTECTED); - if (modifierList.hasExplicitModifier(PsiModifier.PACKAGE_LOCAL)) modifiersSet.add(Modifier.INTERNAL); - if (modifierList.hasExplicitModifier(PsiModifier.PRIVATE)) modifiersSet.add(Modifier.PRIVATE); - } - return modifiersSet; - } - - @NotNull - public static List createConversions(@NotNull PsiCallExpression expression) { - PsiExpressionList argumentList = expression.getArgumentList(); - PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{}; - List conversions = new LinkedList(); - //noinspection UnusedDeclaration - for (final PsiExpression a : arguments) { - conversions.add(""); + if (psiClass.isEnum()) { + return new Enum(name, modifiers, typeParameters, Collections.emptyList(), Collections.emptyList(), implementsTypes, members); + } + return new Class(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, members); } - PsiMethod resolve = expression.resolveMethod(); - if (resolve != null) { - List expectedTypes = new LinkedList(); - List actualTypes = new LinkedList(); + @NotNull + private static Initializer initializerToInitializer(@NotNull PsiClassInitializer i) { + return new Initializer( + blockToBlock(i.getBody(), true), + modifiersListToModifiersSet(i.getModifierList()) + ); + } - for (PsiParameter p : resolve.getParameterList().getParameters()) - expectedTypes.add(p.getType()); + @NotNull + public static String getDefaultInitializer(@NotNull Field f) { + if (f.getType().isNullable()) { + return "null"; + } + else { + final String typeToKotlin = f.getType().toKotlin(); + if (typeToKotlin.equals("Boolean")) return "false"; + if (typeToKotlin.equals("Char")) return "' '"; + if (typeToKotlin.equals("Double")) return "0.dbl"; + if (typeToKotlin.equals("Float")) return "0.flt"; + return "0"; + } + } - for (PsiExpression e : arguments) - actualTypes.add(e.getType()); + @NotNull + private static List fieldsToFieldList(@NotNull PsiField[] fields, PsiClass psiClass) { + List result = new LinkedList(); + for (PsiField f : fields) result.add(fieldToField(f, psiClass)); + return result; + } + + @NotNull + private static Field fieldToField(@NotNull PsiField field, PsiClass psiClass) { + Set modifiers = modifiersListToModifiersSet(field.getModifierList()); + if (field instanceof PsiEnumConstant) // TODO: remove instanceof + { + return new EnumConstant( + new IdentifierImpl(field.getName()), // TODO + modifiers, + typeToType(field.getType()), + elementToElement(((PsiEnumConstant) field).getArgumentList()) + ); + } + return new Field( + new IdentifierImpl(field.getName()), // TODO + modifiers, + typeToType(field.getType()), + createSureCallOnlyForChain(field.getInitializer(), field.getType()), // TODO: add modifiers + countWritingAccesses(field, psiClass) + ); + } + + @Nullable + private static PsiMethod getPrimaryConstructorForThisCase(@NotNull PsiClass psiClass) { + ThisVisitor tv = new ThisVisitor(); + psiClass.accept(tv); + return tv.getPrimaryConstructor(); + } + + public static boolean isConstructorPrimary(@NotNull PsiMethod constructor) { + if (constructor.getParent() instanceof PsiClass) { + final PsiClass parent = (PsiClass) constructor.getParent(); + if (parent.getConstructors().length == 1) { + return true; + } + else { + PsiMethod c = getPrimaryConstructorForThisCase(parent); // TODO: move up to classToClass() method + if (c != null && c.hashCode() == constructor.hashCode()) { + return true; + } + } + } + return false; + } + + @NotNull + private static List removeEmpty(@NotNull List statements) { + List result = new LinkedList(); + for (Statement s : statements) + if (s != Statement.EMPTY_STATEMENT && s != Expression.EMPTY_EXPRESSION) { + result.add(s); + } + return result; + } + + @NotNull + private static Function methodToFunction(@NotNull PsiMethod method) { + return methodToFunction(method, true); + } + + @NotNull + private static Function methodToFunction(@NotNull PsiMethod method, boolean notEmpty) { + if (isOverrideObjectDirect(method)) { + ourDispatcher.setExpressionVisitor(new ExpressionVisitorForDirectObjectInheritors()); + } + else { + ourDispatcher.setExpressionVisitor(new ExpressionVisitor()); + } + + ourMethodReturnType = method.getReturnType(); + + final IdentifierImpl identifier = new IdentifierImpl(method.getName()); + final Type returnType = typeToType(method.getReturnType(), ConverterUtil.isAnnotatedAsNotNull(method.getModifierList())); + final Block body = hasSetting("declarations-only") + ? Block.EMPTY_BLOCK + : blockToBlock(method.getBody(), notEmpty); // #TODO + final Element params = createFunctionParameters(method); + final List typeParameters = elementsToElementList(method.getTypeParameters()); + + final Set modifiers = modifiersListToModifiersSet(method.getModifierList()); + if (isOverrideAnyMethodExceptMethodsFromObject(method)) { + modifiers.add(Modifier.OVERRIDE); + } + if (method.getParent() instanceof PsiClass && ((PsiClass) method.getParent()).isInterface()) { + modifiers.remove(Modifier.ABSTRACT); + } + if (isNotOpenMethod(method)) { + modifiers.add(Modifier.NOT_OPEN); + } + + if (method.isConstructor()) { // TODO: simplify + boolean isPrimary = isConstructorPrimary(method); + return new Constructor( + identifier, + modifiers, + returnType, + typeParameters, + params, + new Block(removeEmpty(body.getStatements()), false), + isPrimary + ); + } + return new Function( + identifier, + modifiers, + returnType, + typeParameters, + params, + body + ); + } + + @NotNull + private static ParameterList createFunctionParameters(@NotNull PsiMethod method) { + List result = new LinkedList(); + for (PsiParameter parameter : method.getParameterList().getParameters()) { + result.add(new Parameter( + new IdentifierImpl(parameter.getName()), + typeToType(parameter.getType(), ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())), + ConverterUtil.isReadOnly(parameter, method.getBody()) + )); + } + return new ParameterList(result); + } + + private static boolean isNotOpenMethod(@NotNull final PsiMethod method) { + if (method.getParent() instanceof PsiClass) { + final PsiModifierList parentModifierList = ((PsiClass) method.getParent()).getModifierList(); + if ((parentModifierList != null && parentModifierList.hasExplicitModifier(Modifier.FINAL)) || ((PsiClass) method.getParent()).isEnum()) { + return true; + } + } + return false; + } + + private static boolean isOverrideAnyMethodExceptMethodsFromObject(@NotNull PsiMethod method) { + boolean counter = normalCase(method); + if (counter) { + return true; + } + if (isInheritFromObject(method)) { + return caseForObject(method); + } + return false; + } + + private static boolean caseForObject(@NotNull PsiMethod method) { + PsiClass containing = method.getContainingClass(); + if (containing != null) { + for (PsiClassType s : containing.getSuperTypes()) { + String canonicalText = s.getCanonicalText(); + if (!canonicalText.equals(JAVA_LANG_OBJECT) && !getClassIdentifiers().contains(canonicalText)) { + return true; + } + } + } + return false; + } + + private static boolean normalCase(@NotNull PsiMethod method) { + int counter = 0; + for (HierarchicalMethodSignature s : method.getHierarchicalMethodSignature().getSuperSignatures()) { + PsiClass containingClass = s.getMethod().getContainingClass(); + String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; + if (qualifiedName != null && !qualifiedName.equals(JAVA_LANG_OBJECT)) { + counter++; + } + } + return counter > 0; + } + + private static boolean isInheritFromObject(@NotNull PsiMethod method) { + List superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures(); + for (HierarchicalMethodSignature s : superSignatures) { + PsiClass containingClass = s.getMethod().getContainingClass(); + String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; + if (qualifiedName != null && qualifiedName.equals(JAVA_LANG_OBJECT)) { + return true; + } + } + return false; + } + + private static boolean isOverrideObjectDirect(@NotNull final PsiMethod method) { + List superSignatures = method.getHierarchicalMethodSignature().getSuperSignatures(); + if (superSignatures.size() == 1) { + final PsiClass containingClass = superSignatures.get(0).getMethod().getContainingClass(); + final String qualifiedName = containingClass != null ? containingClass.getQualifiedName() : ""; + if (qualifiedName != null && qualifiedName.equals(JAVA_LANG_OBJECT)) { + return true; + } + } + return false; + } + + @NotNull + public static Block blockToBlock(@Nullable PsiCodeBlock block, boolean notEmpty) { + if (block == null) return Block.EMPTY_BLOCK; + return new Block(statementsToStatementList(block.getStatements()), notEmpty); + } + + @NotNull + public static Block blockToBlock(@Nullable PsiCodeBlock block) { + return blockToBlock(block, true); + } + + @NotNull + public static List statementsToStatementList(@NotNull PsiStatement[] statements) { + List result = new LinkedList(); + for (PsiStatement t : statements) result.add(statementToStatement(t)); + return result; + } + + @NotNull + public static List statementsToStatementList(@NotNull List statements) { + List result = new LinkedList(); + for (PsiStatement t : statements) result.add(statementToStatement(t)); + return result; + } + + @NotNull + public static Statement statementToStatement(@Nullable PsiStatement s) { + if (s == null) return Statement.EMPTY_STATEMENT; + final StatementVisitor statementVisitor = new StatementVisitor(); + s.accept(statementVisitor); + return statementVisitor.getResult(); + } + + @NotNull + public static List expressionsToExpressionList(@NotNull PsiExpression[] expressions) { + List result = new LinkedList(); + for (PsiExpression e : expressions) result.add(expressionToExpression(e)); + return result; + } + + @NotNull + public static Expression expressionToExpression(@Nullable PsiExpression e) { + if (e == null) return Expression.EMPTY_EXPRESSION; + final ExpressionVisitor expressionVisitor = ourDispatcher.getExpressionVisitor(); + e.accept(expressionVisitor); + return expressionVisitor.getResult(); + } + + @NotNull + public static Element elementToElement(@Nullable PsiElement e) { + if (e == null) return Element.EMPTY_ELEMENT; + final ElementVisitor elementVisitor = new ElementVisitor(); + e.accept(elementVisitor); + return elementVisitor.getResult(); + } + + @NotNull + public static List elementsToElementList(@NotNull PsiElement[] elements) { + List result = new LinkedList(); + for (PsiElement e : elements) result.add(elementToElement(e)); + return result; + } + + @NotNull + public static Type typeToType(@Nullable PsiType type) { + if (type == null) return Type.EMPTY_TYPE; + TypeVisitor typeVisitor = new TypeVisitor(); + type.accept(typeVisitor); + return typeVisitor.getResult(); + } + + @NotNull + public static List typesToTypeList(@NotNull PsiType[] types) { + List result = new LinkedList(); + for (PsiType t : types) result.add(typeToType(t)); + return result; + } + + @NotNull + public static Type typeToType(PsiType type, boolean notNull) { + Type result = typeToType(type); + if (notNull) { + result.convertedToNotNull(); + } + return result; + } + + @NotNull + private static List typesToNotNullableTypeList(@NotNull PsiType[] types) { + List result = new LinkedList(typesToTypeList(types)); + for (Type p : result) p.convertedToNotNull(); + return result; + } + + @NotNull + private static List importsToImportList(@NotNull PsiImportStatementBase[] imports) { + List result = new LinkedList(); + for (PsiImportStatementBase i : imports) { + Import anImport = importToImport(i); + String name = anImport.getName(); + if (!name.isEmpty() && !NOT_NULL_ANNOTATIONS.contains(name)) { + result.add(anImport); + } + } + return result; + } + + @NotNull + private static Import importToImport(@NotNull PsiImportStatementBase i) { + final PsiJavaCodeReferenceElement reference = i.getImportReference(); + if (reference != null) { + return new Import(quoteKeywords(reference.getQualifiedName()) + (i.isOnDemand() ? ".*" : "")); + } + return new Import(""); + } + + @NotNull + public static List parametersToParameterList(@NotNull PsiParameter[] parameters) { + List result = new LinkedList(); + for (PsiParameter t : parameters) result.add(parameterToParameter(t)); + return result; + } + + @NotNull + public static Parameter parameterToParameter(@NotNull PsiParameter parameter) { + return new Parameter( + new IdentifierImpl(parameter.getName()), + typeToType(parameter.getType(), ConverterUtil.isAnnotatedAsNotNull(parameter.getModifierList())) + ); + } + + @NotNull + public static Identifier identifierToIdentifier(@Nullable PsiIdentifier identifier) { + if (identifier == null) return Identifier.EMPTY_IDENTIFIER; + return new IdentifierImpl(identifier.getText()); + } + + @NotNull + public static Set modifiersListToModifiersSet(@Nullable PsiModifierList modifierList) { + HashSet modifiersSet = new HashSet(); + if (modifierList != null) { + if (modifierList.hasExplicitModifier(PsiModifier.ABSTRACT)) modifiersSet.add(Modifier.ABSTRACT); + if (modifierList.hasModifierProperty(PsiModifier.FINAL)) modifiersSet.add(Modifier.FINAL); + if (modifierList.hasModifierProperty(PsiModifier.STATIC)) modifiersSet.add(Modifier.STATIC); + if (modifierList.hasExplicitModifier(PsiModifier.PUBLIC)) modifiersSet.add(Modifier.PUBLIC); + if (modifierList.hasExplicitModifier(PsiModifier.PROTECTED)) modifiersSet.add(Modifier.PROTECTED); + if (modifierList.hasExplicitModifier(PsiModifier.PACKAGE_LOCAL)) modifiersSet.add(Modifier.INTERNAL); + if (modifierList.hasExplicitModifier(PsiModifier.PRIVATE)) modifiersSet.add(Modifier.PRIVATE); + } + return modifiersSet; + } + + @NotNull + public static List createConversions(@NotNull PsiCallExpression expression) { + PsiExpressionList argumentList = expression.getArgumentList(); + PsiExpression[] arguments = argumentList != null ? argumentList.getExpressions() : new PsiExpression[]{}; + List conversions = new LinkedList(); + //noinspection UnusedDeclaration + for (final PsiExpression a : arguments) { + conversions.add(""); + } + + PsiMethod resolve = expression.resolveMethod(); + if (resolve != null) { + List expectedTypes = new LinkedList(); + List actualTypes = new LinkedList(); + + for (PsiParameter p : resolve.getParameterList().getParameters()) + expectedTypes.add(p.getType()); + + for (PsiExpression e : arguments) + actualTypes.add(e.getType()); + + if (conversions.size() == actualTypes.size() && actualTypes.size() == expectedTypes.size()) { + for (int i = 0; i < actualTypes.size(); i++) + conversions.set(i, createConversionForExpression(arguments[i], expectedTypes.get(i))); + } + } + return conversions; + } + + @NotNull + public static List createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) { + PsiExpression[] arguments = expression.getOperands(); + int length = arguments.length; + List conversions = new LinkedList(); + + List expectedTypes = Collections.nCopies(length, expectedType); + List actualTypes = new LinkedList(); + + for (PsiExpression e : arguments) + actualTypes.add(e.getType()); + + assert actualTypes.size() == expectedTypes.size() : "The type list must have the same length"; - if (conversions.size() == actualTypes.size() && actualTypes.size() == expectedTypes.size()) { for (int i = 0; i < actualTypes.size(); i++) - conversions.set(i, createConversionForExpression(arguments[i], expectedTypes.get(i))); - } + conversions.add(i, createConversionForExpression(arguments[i], expectedTypes.get(i))); + + return conversions; } - return conversions; - } - @NotNull - public static List createConversions(@NotNull PsiPolyadicExpression expression, PsiType expectedType) { - PsiExpression[] arguments = expression.getOperands(); - int length = arguments.length; - List conversions = new LinkedList(); + @NotNull + private static String createConversionForExpression(@Nullable PsiExpression expression, @NotNull PsiType expectedType) { + String conversion = ""; + if (expression != null) { + PsiType actualType = expression.getType(); + boolean isPrimitiveTypeOrNull = actualType == null || Node.PRIMITIVE_TYPES.contains(actualType.getCanonicalText()); + boolean isRef = (expression instanceof PsiReferenceExpression && ((PsiReferenceExpression) expression).isQualified() || expression instanceof PsiMethodCallExpression); + boolean containsQuestDot = expressionToExpression(expression).toKotlin().contains("?."); - List expectedTypes = Collections.nCopies(length, expectedType); - List actualTypes = new LinkedList(); + if (isPrimitiveTypeOrNull && isRef && containsQuestDot) { + conversion += ".sure()"; + } - for (PsiExpression e : arguments) - actualTypes.add(e.getType()); - - assert actualTypes.size() == expectedTypes.size() : "The type list must have the same length"; - - for (int i = 0; i < actualTypes.size(); i++) - conversions.add(i, createConversionForExpression(arguments[i], expectedTypes.get(i))); - - return conversions; - } - - @NotNull - private static String createConversionForExpression(@Nullable PsiExpression expression, @NotNull PsiType expectedType) { - String conversion = ""; - if (expression != null) { - PsiType actualType = expression.getType(); - boolean isPrimitiveTypeOrNull = actualType == null || Node.PRIMITIVE_TYPES.contains(actualType.getCanonicalText()); - boolean isRef = (expression instanceof PsiReferenceExpression && ((PsiReferenceExpression) expression).isQualified() || expression instanceof PsiMethodCallExpression); - boolean containsQuestDot = expressionToExpression(expression).toKotlin().contains("?."); - - if (isPrimitiveTypeOrNull && isRef && containsQuestDot) - conversion += ".sure()"; - - if (actualType != null) - if (isConversionNeeded(actualType, expectedType)) - conversion += getPrimitiveTypeConversion(expectedType.getCanonicalText()); + if (actualType != null) { + if (isConversionNeeded(actualType, expectedType)) { + conversion += getPrimitiveTypeConversion(expectedType.getCanonicalText()); + } + } + } + return conversion; } - return conversion; - } - private static boolean isConversionNeeded(@Nullable final PsiType actual, @Nullable final PsiType expected) { - if (actual == null || expected == null) - return false; - Map typeMap = new HashMap(); - typeMap.put(JAVA_LANG_BYTE, "byte"); - typeMap.put(JAVA_LANG_SHORT, "short"); - typeMap.put(JAVA_LANG_INTEGER, "int"); - typeMap.put(JAVA_LANG_LONG, "long"); - typeMap.put(JAVA_LANG_FLOAT, "float"); - typeMap.put(JAVA_LANG_DOUBLE, "double"); - typeMap.put(JAVA_LANG_CHARACTER, "char"); - String expectedStr = expected.getCanonicalText(); - String actualStr = actual.getCanonicalText(); - boolean o1 = AstUtil.getOrElse(typeMap, actualStr, "").equals(expectedStr); - boolean o2 = AstUtil.getOrElse(typeMap, expectedStr, "").equals(actualStr); - return !actualStr.equals(expectedStr) && (!(o1 ^ o2)); - } + private static boolean isConversionNeeded(@Nullable final PsiType actual, @Nullable final PsiType expected) { + if (actual == null || expected == null) { + return false; + } + Map typeMap = new HashMap(); + typeMap.put(JAVA_LANG_BYTE, "byte"); + typeMap.put(JAVA_LANG_SHORT, "short"); + typeMap.put(JAVA_LANG_INTEGER, "int"); + typeMap.put(JAVA_LANG_LONG, "long"); + typeMap.put(JAVA_LANG_FLOAT, "float"); + typeMap.put(JAVA_LANG_DOUBLE, "double"); + typeMap.put(JAVA_LANG_CHARACTER, "char"); + String expectedStr = expected.getCanonicalText(); + String actualStr = actual.getCanonicalText(); + boolean o1 = AstUtil.getOrElse(typeMap, actualStr, "").equals(expectedStr); + boolean o2 = AstUtil.getOrElse(typeMap, expectedStr, "").equals(actualStr); + return !actualStr.equals(expectedStr) && (!(o1 ^ o2)); + } - @NotNull - private static String getPrimitiveTypeConversion(@NotNull String type) { - Map conversions = new HashMap(); - conversions.put("byte", "byt"); - conversions.put("short", "sht"); - conversions.put("int", "int"); - conversions.put("long", "lng"); - conversions.put("float", "flt"); - conversions.put("double", "dbl"); - conversions.put("char", "chr"); + @NotNull + private static String getPrimitiveTypeConversion(@NotNull String type) { + Map conversions = new HashMap(); + conversions.put("byte", "byt"); + conversions.put("short", "sht"); + conversions.put("int", "int"); + conversions.put("long", "lng"); + conversions.put("float", "flt"); + conversions.put("double", "dbl"); + conversions.put("char", "chr"); - conversions.put(JAVA_LANG_BYTE, "byt"); - conversions.put(JAVA_LANG_SHORT, "sht"); - conversions.put(JAVA_LANG_INTEGER, "int"); - conversions.put(JAVA_LANG_LONG, "lng"); - conversions.put(JAVA_LANG_FLOAT, "flt"); - conversions.put(JAVA_LANG_DOUBLE, "dbl"); - conversions.put(JAVA_LANG_CHARACTER, "chr"); + conversions.put(JAVA_LANG_BYTE, "byt"); + conversions.put(JAVA_LANG_SHORT, "sht"); + conversions.put(JAVA_LANG_INTEGER, "int"); + conversions.put(JAVA_LANG_LONG, "lng"); + conversions.put(JAVA_LANG_FLOAT, "flt"); + conversions.put(JAVA_LANG_DOUBLE, "dbl"); + conversions.put(JAVA_LANG_CHARACTER, "chr"); - if (conversions.containsKey(type)) - return "." + conversions.get(type); - return ""; - } + if (conversions.containsKey(type)) { + return "." + conversions.get(type); + } + return ""; + } // @NotNull // private static String applyConversion(Expression expression, String conversion) { @@ -744,11 +790,13 @@ public class Converter { // return "(" + expression.toKotlin() + ")" + conversion; // } - @NotNull - public static SureCallChainExpression createSureCallOnlyForChain(@Nullable PsiExpression expression, @NotNull PsiType type) { - String conversion = (expression != null && (expression instanceof PsiReferenceExpression || expression instanceof PsiMethodCallExpression)) ? - createConversionForExpression(expression, type) : ""; - return new SureCallChainExpression(expressionToExpression(expression), conversion); - } + @NotNull + public static SureCallChainExpression createSureCallOnlyForChain(@Nullable PsiExpression expression, @NotNull PsiType type) { + String conversion = (expression != null && (expression instanceof PsiReferenceExpression || expression instanceof PsiMethodCallExpression)) + ? + createConversionForExpression(expression, type) + : ""; + return new SureCallChainExpression(expressionToExpression(expression), conversion); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ConverterUtil.java b/j2k/src/org/jetbrains/jet/j2k/ConverterUtil.java index a979ff61be1..fbf6effdda5 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ConverterUtil.java +++ b/j2k/src/org/jetbrains/jet/j2k/ConverterUtil.java @@ -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> classNamesWithMains = new LinkedList>(); - - for (PsiClass c : ((PsiJavaFile) file).getClasses()) { - PsiMethod main = findMainMethod(c); - if (main != null) { - classNamesWithMains.add(new Pair(c.getName(), main)); - } - } - if (classNamesWithMains.size() > 0) { - String className = classNamesWithMains.get(0).getFirst(); - return MessageFormat.format("fun main(args : Array?) = {0}.main(args)", className); - } - return ""; - } - - @Nullable - private static PsiMethod findMainMethod(@NotNull PsiClass aClass) { - if (isMainClass(aClass)) { - final PsiMethod[] mainMethods = aClass.findMethodsByName("main", false); - return findMainMethod(mainMethods); - } - return null; - } - - @Nullable - private static PsiMethod findMainMethod(@NotNull PsiMethod[] mainMethods) { - for (PsiMethod mainMethod : mainMethods) { - if (isMainMethod(mainMethod)) return mainMethod; - } - return null; - } - - private static boolean isMainClass(@NotNull PsiClass psiClass) { - if (psiClass instanceof PsiAnonymousClass) return false; - if (psiClass.isInterface()) return false; - return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC); - } - - public static boolean isMainMethod(@Nullable PsiMethod method) { - if (method == null || method.getContainingClass() == null) return false; - if (PsiType.VOID != method.getReturnType()) return false; - if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; - if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false; - final PsiParameter[] parameters = method.getParameterList().getParameters(); - if (parameters.length != 1) return false; - final PsiType type = parameters[0].getType(); - if (!(type instanceof PsiArrayType)) return false; - final PsiType componentType = ((PsiArrayType) type).getComponentType(); - return componentType.equalsToText("java.lang.String"); - } - - public static int countWritingAccesses(@Nullable PsiElement element, @Nullable PsiElement container) { - int counter = 0; - if (container != null) { - ReferenceCollector visitor = new ReferenceCollector(); - container.accept(visitor); - for (PsiReferenceExpression e : visitor.getCollectedReferences()) - if (e.isReferenceTo(element) && PsiUtil.isAccessedForWriting(e)) - counter++; - } - return counter; - } - - 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 getCollectedReferences() { - return myCollectedReferences; + private ConverterUtil() { } - private List myCollectedReferences = new LinkedList(); + @NotNull + public static String createMainFunction(@NotNull PsiFile file) { + List> classNamesWithMains = new LinkedList>(); - @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(c.getName(), main)); + } + } + if (classNamesWithMains.size() > 0) { + String className = classNamesWithMains.get(0).getFirst(); + return MessageFormat.format("fun main(args : Array?) = {0}.main(args)", className); + } + return ""; + } + + @Nullable + private static PsiMethod findMainMethod(@NotNull PsiClass aClass) { + if (isMainClass(aClass)) { + final PsiMethod[] mainMethods = aClass.findMethodsByName("main", false); + return findMainMethod(mainMethods); + } + return null; + } + + @Nullable + private static PsiMethod findMainMethod(@NotNull PsiMethod[] mainMethods) { + for (PsiMethod mainMethod : mainMethods) { + if (isMainMethod(mainMethod)) return mainMethod; + } + return null; + } + + private static boolean isMainClass(@NotNull PsiClass psiClass) { + if (psiClass instanceof PsiAnonymousClass) return false; + if (psiClass.isInterface()) return false; + return psiClass.getContainingClass() == null || psiClass.hasModifierProperty(PsiModifier.STATIC); + } + + public static boolean isMainMethod(@Nullable PsiMethod method) { + if (method == null || method.getContainingClass() == null) return false; + if (PsiType.VOID != method.getReturnType()) return false; + if (!method.hasModifierProperty(PsiModifier.STATIC)) return false; + if (!method.hasModifierProperty(PsiModifier.PUBLIC)) return false; + final PsiParameter[] parameters = method.getParameterList().getParameters(); + if (parameters.length != 1) return false; + final PsiType type = parameters[0].getType(); + if (!(type instanceof PsiArrayType)) return false; + final PsiType componentType = ((PsiArrayType) type).getComponentType(); + return componentType.equalsToText("java.lang.String"); + } + + public static int countWritingAccesses(@Nullable PsiElement element, @Nullable PsiElement container) { + int counter = 0; + if (container != null) { + ReferenceCollector visitor = new ReferenceCollector(); + container.accept(visitor); + for (PsiReferenceExpression e : visitor.getCollectedReferences()) + if (e.isReferenceTo(element) && PsiUtil.isAccessedForWriting(e)) { + counter++; + } + } + return counter; + } + + 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 getCollectedReferences() { + return myCollectedReferences; + } + + private List myCollectedReferences = new LinkedList(); + + @Override + public void visitReferenceExpression(PsiReferenceExpression expression) { + super.visitReferenceExpression(expression); + myCollectedReferences.add(expression); + } } - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java index f87a8952a6e..3256b711c4c 100644 --- a/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java +++ b/j2k/src/org/jetbrains/jet/j2k/JavaToKotlinTranslator.java @@ -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() { - @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() { + @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)."); + } } - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/SetupJavaCoreEnvironmentException.java b/j2k/src/org/jetbrains/jet/j2k/SetupJavaCoreEnvironmentException.java index bbe7e064ac8..d7bde2ad4d1 100644 --- a/j2k/src/org/jetbrains/jet/j2k/SetupJavaCoreEnvironmentException.java +++ b/j2k/src/org/jetbrains/jet/j2k/SetupJavaCoreEnvironmentException.java @@ -4,6 +4,6 @@ package org.jetbrains.jet.j2k; * @author ignatov */ public class SetupJavaCoreEnvironmentException extends RuntimeException { - public SetupJavaCoreEnvironmentException(String s) { - } + public SetupJavaCoreEnvironmentException(String s) { + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java index c5524a0bb91..d171f533f51 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AnonymousClass.java @@ -9,20 +9,20 @@ import java.util.List; * @author ignatov */ public class AnonymousClass extends Class { - public AnonymousClass(List members) { - super(new IdentifierImpl("anonClass"), - Collections.emptySet(), - Collections.emptyList(), - Collections.emptyList(), - Collections.emptyList(), - Collections.emptyList(), - getMembers(members) - ); - } + public AnonymousClass(List members) { + super(new IdentifierImpl("anonClass"), + Collections.emptySet(), + Collections.emptyList(), + Collections.emptyList(), + Collections.emptyList(), + Collections.emptyList(), + getMembers(members) + ); + } - @NotNull - @Override - public String toKotlin() { - return bodyToKotlin(); - } + @NotNull + @Override + public String toKotlin() { + return bodyToKotlin(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayAccessExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayAccessExpression.java index 4a511b713b9..a9d38805fa9 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayAccessExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayAccessExpression.java @@ -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() + "]"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.java index b08f1b7bf6b..539673d731b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayInitializerExpression.java @@ -9,62 +9,64 @@ import java.util.*; * @author ignatov */ public class ArrayInitializerExpression extends Expression { - private final Type myType; - private final List myInitializers; + private final Type myType; + private final List myInitializers; - public ArrayInitializerExpression(final Type type, List 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 - } - - @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 initializers) { - List arguments = new LinkedList(); - 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 doubleOrFloatTypes = new HashSet( - 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 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 + } - @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 initializers) { + List arguments = new LinkedList(); + 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 doubleOrFloatTypes = new HashSet( + 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) + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayType.java b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayType.java index d78994faf55..5707ba50170 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayType.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.java index 44169fca924..1f97a34a5f2 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ArrayWithoutInitializationExpression.java @@ -9,45 +9,48 @@ import java.util.List; * @author ignatov */ public class ArrayWithoutInitializationExpression extends Expression { - private final Type myType; - private final List myExpressions; + private final Type myType; + private final List myExpressions; - public ArrayWithoutInitializationExpression(Type type, List expressions) { - myType = type; - myExpressions = expressions; - } + public ArrayWithoutInitializationExpression(Type type, List 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 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 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()); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.java index 829f7953948..c75f7f82c6f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AssertStatement.java @@ -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() + "}"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/AssignmentExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/AssignmentExpression.java index 34d1fcb7b20..94bf9982197 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/AssignmentExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/AssignmentExpression.java @@ -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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/BinaryExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/BinaryExpression.java index 2df6bfd2dd6..683ab7a8af3 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/BinaryExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/BinaryExpression.java @@ -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 myConversions; + private final Expression myLeft; + private final Expression myRight; + private final String myOp; + private final List 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 conversions) { - myLeft = left; - myRight = right; - myOp = op; - myConversions = conversions; - } + public BinaryExpression(Expression left, Expression right, String op, List conversions) { + myLeft = left; + myRight = right; + myOp = op; + myConversions = conversions; + } - @NotNull - @Override - public String toKotlin() { - List expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(Arrays.asList(myLeft, myRight)), myConversions); - return AstUtil.join(expressionsWithConversions, SPACE + myOp + SPACE); - } + @NotNull + @Override + public String toKotlin() { + List expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(Arrays.asList(myLeft, myRight)), myConversions); + return AstUtil.join(expressionsWithConversions, SPACE + myOp + SPACE); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Block.java b/j2k/src/org/jetbrains/jet/j2k/ast/Block.java index 3e22f8fb775..b4e8f449539 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Block.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Block.java @@ -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 myStatements; - private boolean myNotEmpty = false; + private List myStatements; + private boolean myNotEmpty = false; - private Block() { - myStatements = new LinkedList(); - } + private Block() { + myStatements = new LinkedList(); + } - public Block(List statements) { - myStatements = new LinkedList(); - myStatements = statements; - } + public Block(List statements) { + myStatements = new LinkedList(); + myStatements = statements; + } - public Block(List statements, boolean notEmpty) { - myStatements = new LinkedList(); - myStatements = statements; - myNotEmpty = notEmpty; - } + public Block(List statements, boolean notEmpty) { + myStatements = new LinkedList(); + myStatements = statements; + myNotEmpty = notEmpty; + } - public boolean isEmpty() { - return !myNotEmpty && myStatements.size() == 0; - } + public boolean isEmpty() { + return !myNotEmpty && myStatements.size() == 0; + } - public List getStatements() { - return myStatements; - } + public List 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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/BreakStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/BreakStatement.java index e48b8ad5b5d..477037b0cad 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/BreakStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/BreakStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.java index d98463f24c1..d6c029f7c5d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/CallChainExpression.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/CaseContainer.java b/j2k/src/org/jetbrains/jet/j2k/ast/CaseContainer.java index b96b7be351f..764e8f78493 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/CaseContainer.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/CaseContainer.java @@ -10,21 +10,22 @@ import java.util.List; * @author ignatov */ public class CaseContainer extends Statement { - private final List myCaseStatement; - private final Block myBlock; + private final List myCaseStatement; + private final Block myBlock; - public CaseContainer(final List caseStatement, @NotNull final List statements) { - myCaseStatement = caseStatement; - List newStatements = new LinkedList(); - for (Statement s : statements) - if (s.getKind() != Kind.BREAK && s.getKind() != Kind.CONTINUE) - newStatements.add(s); - myBlock = new Block(newStatements); - } + public CaseContainer(final List caseStatement, @NotNull final List statements) { + myCaseStatement = caseStatement; + List newStatements = new LinkedList(); + 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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/CatchStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/CatchStatement.java index 7db33c91163..69e39808ae2 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/CatchStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/CatchStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Class.java b/j2k/src/org/jetbrains/jet/j2k/ast/Class.java index dbc9e9fa710..77b27d2637b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Class.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Class.java @@ -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 myBaseClassParams; - private final List myMembers; - private final List myTypeParameters; - private final List myExtendsTypes; - private final List myImplementsTypes; + @NotNull + String TYPE = "class"; + final Identifier myName; + private final List myBaseClassParams; + private final List myMembers; + private final List myTypeParameters; + private final List myExtendsTypes; + private final List myImplementsTypes; - public Class(Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - myName = name; - myBaseClassParams = baseClassParams; - myModifiers = modifiers; - myTypeParameters = typeParameters; - myExtendsTypes = extendsTypes; - myImplementsTypes = implementsTypes; - myMembers= getMembers(members); - } + public Class(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + List baseClassParams, List implementsTypes, List members) { + myName = name; + myBaseClassParams = baseClassParams; + myModifiers = modifiers; + myTypeParameters = typeParameters; + myExtendsTypes = extendsTypes; + myImplementsTypes = implementsTypes; + myMembers = getMembers(members); + } - static List getMembers(List members) { - List withoutPrivate = new LinkedList(); - if (Converter.hasSetting("public-only")) { - for (Member m : members) { - if (m.accessModifier().equals("public") || m.accessModifier().equals("protected")) { - withoutPrivate.add(m); + static List getMembers(List members) { + List withoutPrivate = new LinkedList(); + 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 wheres = new LinkedList(); - 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 membersExceptConstructors() { - final LinkedList result = new LinkedList(); - for (Member m : myMembers) - if (m.getKind() != Kind.CONSTRUCTOR) - result.add(m); - return result; - } - - @NotNull - List secondaryConstructorsAsStaticInitFunction() { - final LinkedList result = new LinkedList(); - for (Member m : myMembers) - if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).isPrimary()) { - Function f = (Function) m; - Set modifiers = new HashSet(m.myModifiers); - modifiers.add(Modifier.STATIC); - - final List 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 typeParameters = new LinkedList(); - 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 wheres = new LinkedList(); + 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 membersExceptConstructors() { + final LinkedList result = new LinkedList(); + for (Member m : myMembers) + if (m.getKind() != Kind.CONSTRUCTOR) { + result.add(m); + } + return result; + } + + @NotNull + List secondaryConstructorsAsStaticInitFunction() { + final LinkedList result = new LinkedList(); + for (Member m : myMembers) + if (m.getKind() == Kind.CONSTRUCTOR && !((Constructor) m).isPrimary()) { + Function f = (Function) m; + Set modifiers = new HashSet(m.myModifiers); + modifiers.add(Modifier.STATIC); + + final List 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 typeParameters = new LinkedList(); + 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 baseClassSignatureWithParams() { + if (TYPE.equals("class") && myExtendsTypes.size() == 1) { + LinkedList result = new LinkedList(); + result.add(myExtendsTypes.get(0).toKotlin() + "(" + joinNodes(myBaseClassParams, COMMA_WITH_SPACE) + ")"); + return result; + } + else { + return nodesToKotlin(myExtendsTypes); + } + } + + @NotNull + String implementTypesToKotlin() { + List allTypes = new LinkedList() { + { + addAll(baseClassSignatureWithParams()); + addAll(nodesToKotlin(myImplementsTypes)); + } + }; + return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE); + } + + @NotNull + String modifiersToKotlin() { + List modifierList = new LinkedList(); + + 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 baseClassSignatureWithParams() { - if (TYPE.equals("class") && myExtendsTypes.size() == 1) { - LinkedList result = new LinkedList(); - 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 allTypes = new LinkedList() { - { - addAll(baseClassSignatureWithParams()); - addAll(nodesToKotlin(myImplementsTypes)); - } - }; - return allTypes.size() == 0 ? EMPTY : SPACE + COLON + SPACE + join(allTypes, COMMA_WITH_SPACE); - } - - @NotNull - String modifiersToKotlin() { - List modifierList = new LinkedList(); - - 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 getStatic(@NotNull List members) { - List result = new LinkedList(); - for (Member m : members) - if (m.isStatic()) - result.add(m); - return result; - } - - @NotNull - private static List getNonStatic(@NotNull List members) { - List result = new LinkedList(); - for (Member m : members) - if (!m.isStatic()) - result.add(m); - return result; - } - - @NotNull - private String classObjectToKotlin() { - final List staticMembers = new LinkedList(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 getStatic(@NotNull List members) { + List result = new LinkedList(); + for (Member m : members) + if (m.isStatic()) { + result.add(m); + } + return result; + } + + @NotNull + private static List getNonStatic(@NotNull List members) { + List result = new LinkedList(); + for (Member m : members) + if (!m.isStatic()) { + result.add(m); + } + return result; + } + + @NotNull + private String classObjectToKotlin() { + final List staticMembers = new LinkedList(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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ClassObjectAccessExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ClassObjectAccessExpression.java index b16fedbf19e..cb23cad7765 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ClassObjectAccessExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ClassObjectAccessExpression.java @@ -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() + ">"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ClassType.java b/j2k/src/org/jetbrains/jet/j2k/ast/ClassType.java index 5e330877280..700249dbf8b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ClassType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ClassType.java @@ -10,30 +10,32 @@ import java.util.List; * @author ignatov */ public class ClassType extends Type { - private final Identifier myType; - private final List myParameters; + private final Identifier myType; + private final List myParameters; - public ClassType(Identifier type, List parameters, boolean nullable) { - myType = type; - myParameters = parameters; - myNullable = nullable; - } + public ClassType(Identifier type, List parameters, boolean nullable) { + myType = type; + myParameters = parameters; + myNullable = nullable; + } - public ClassType(Identifier type, List parameters) { - myType = type; - myParameters = parameters; - } + public ClassType(Identifier type, List 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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.java b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.java index 758928b7295..f317d9a9275 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Constructor.java @@ -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 modifiers, Type type, List typeParameters, Element params, Block block, boolean isPrimary) { - super(identifier, modifiers, type, typeParameters, params, block); - myIsPrimary = isPrimary; - } + public Constructor(Identifier identifier, Set modifiers, Type type, List 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; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ContinueStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ContinueStatement.java index bfed924d439..ed63d01f4f6 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ContinueStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ContinueStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DeclarationStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/DeclarationStatement.java index d9bbcb5f7d8..b2da4b0361a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DeclarationStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DeclarationStatement.java @@ -10,31 +10,31 @@ import java.util.List; * @author ignatov */ public class DeclarationStatement extends Statement { - private final List myElements; + private final List myElements; - public DeclarationStatement(List elements) { - myElements = elements; - } - - @NotNull - private static List toStringList(@NotNull List elements) { - List result = new LinkedList(); - 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 elements) { + myElements = elements; } - return result; - } - @NotNull - @Override - public String toKotlin() { - return AstUtil.join(toStringList(myElements), N); - } + @NotNull + private static List toStringList(@NotNull List elements) { + List result = new LinkedList(); + 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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DefaultSwitchLabelStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/DefaultSwitchLabelStatement.java index a148197da77..a1cf0d2668f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DefaultSwitchLabelStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DefaultSwitchLabelStatement.java @@ -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"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DoWhileStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/DoWhileStatement.java index 02d4f64d58d..1818088b2f5 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DoWhileStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DoWhileStatement.java @@ -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() + ")"; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DummyMethodCallExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/DummyMethodCallExpression.java index e304161c987..f8013cc42f0 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DummyMethodCallExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DummyMethodCallExpression.java @@ -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() + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.java index 0c3eb6717db..4eb000ccf30 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/DummyStringExpression.java @@ -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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Element.java b/j2k/src/org/jetbrains/jet/j2k/ast/Element.java index 56bf2c4daa5..9a5efe5f832 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Element.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Element.java @@ -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; + } } - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java index cbf2cc7872c..ca61fcebbb0 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Enum.java @@ -10,30 +10,30 @@ import java.util.Set; * @author ignatov */ public class Enum extends Class { - public Enum(Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members)); - } + public Enum(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + List baseClassParams, List implementsTypes, List 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 + + "}"; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.java b/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.java index d9aba8ef463..ad1faf167ea 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/EnumConstant.java @@ -8,15 +8,16 @@ import java.util.Set; * @author ignatov */ public class EnumConstant extends Field { - public EnumConstant(Identifier identifier, Set modifiers, @NotNull Type type, Element params) { - super(identifier, modifiers, type.convertedToNotNull(), params, 0); - } + public EnumConstant(Identifier identifier, Set 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() + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.java b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.java index d3a98436c8b..c8a550fae84 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Expression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Expression.java @@ -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; - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.java b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.java index ae3c1358f58..23e9528df8a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionList.java @@ -9,19 +9,19 @@ import java.util.List; * @author ignatov */ public class ExpressionList extends Expression { - private final List myExpressions; + private final List myExpressions; - public ExpressionList(List expressions, List types) { - myExpressions = expressions; - } + public ExpressionList(List expressions, List types) { + myExpressions = expressions; + } - public ExpressionList(List expressions) { - myExpressions = expressions; - } + public ExpressionList(List 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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionListStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionListStatement.java index 1c67340e655..45ec4b15a2b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionListStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ExpressionListStatement.java @@ -9,15 +9,15 @@ import java.util.List; * @author ignatov */ public class ExpressionListStatement extends Expression { - private final List myExpressions; + private final List myExpressions; - public ExpressionListStatement(List expressions) { - myExpressions = expressions; - } + public ExpressionListStatement(List expressions) { + myExpressions = expressions; + } - @NotNull - @Override - public String toKotlin() { - return AstUtil.joinNodes(myExpressions, N); - } + @NotNull + @Override + public String toKotlin() { + return AstUtil.joinNodes(myExpressions, N); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Field.java b/j2k/src/org/jetbrains/jet/j2k/ast/Field.java index 35e364aa09f..3d5dd835ba2 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Field.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Field.java @@ -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 modifiers, Type type, Element initializer, int writingAccesses) { - myIdentifier = identifier; - myWritingAccesses = writingAccesses; - myModifiers = modifiers; - myType = type; - myInitializer = initializer; - } + public Field(Identifier identifier, Set 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 modifierList = new LinkedList(); + @NotNull + String modifiersToKotlin() { + List modifierList = new LinkedList(); - 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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/File.java b/j2k/src/org/jetbrains/jet/j2k/ast/File.java index 0dd63fa4fd6..a2f3078abcb 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/File.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/File.java @@ -9,25 +9,26 @@ import java.util.List; * @author ignatov */ public class File extends Node { - private final String myPackageName; - private final List myImports; - private final List myClasses; - private final String myMainFunction; + private final String myPackageName; + private final List myImports; + private final List myClasses; + private final String myMainFunction; - public File(String packageName, List imports, List classes, String mainFunction) { - myPackageName = packageName; - myImports = imports; - myClasses = classes; - myMainFunction = mainFunction; - } + public File(String packageName, List imports, List 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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ForeachStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ForeachStatement.java index 08f2a457b11..7b9e235feb5 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ForeachStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ForeachStatement.java @@ -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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ForeachWithRangeStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ForeachWithRangeStatement.java index b6aa9e622e0..86233d19c90 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ForeachWithRangeStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ForeachWithRangeStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Function.java b/j2k/src/org/jetbrains/jet/j2k/ast/Function.java index cf03d2de8a7..ee71522f42a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Function.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Function.java @@ -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 myTypeParameters; - final Element myParams; + private final Identifier myName; + private final Type myType; + private final List myTypeParameters; + final Element myParams; - // TODO: maybe remove it? - public void setBlock(Block block) { - myBlock = block; - } - - Block myBlock; - - public Function(Identifier name, Set modifiers, Type type, List typeParameters, Element params, Block block) { - myName = name; - myModifiers = modifiers; - myType = type; - myTypeParameters = typeParameters; - myParams = params; - myBlock = block; - } - - public List 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 wheres = new LinkedList(); - 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 modifierList = new LinkedList(); + Block myBlock; - if (isAbstract()) - modifierList.add(Modifier.ABSTRACT); + public Function(Identifier name, Set modifiers, Type type, List 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 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 wheres = new LinkedList(); + 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 modifierList = new LinkedList(); + + 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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/IMember.java b/j2k/src/org/jetbrains/jet/j2k/ast/IMember.java index 3ac5ac6c31b..a3f5c61c7f2 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/IMember.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/IMember.java @@ -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(); } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/INode.java b/j2k/src/org/jetbrains/jet/j2k/ast/INode.java index d4c23a7a484..17941ee5e99 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/INode.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/INode.java @@ -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, + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.java b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.java index 8191f63b0c2..3896a6355f7 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Identifier.java @@ -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(); } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/IdentifierImpl.java b/j2k/src/org/jetbrains/jet/j2k/ast/IdentifierImpl.java index 6a1b4fbff11..eaacc076eeb 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/IdentifierImpl.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/IdentifierImpl.java @@ -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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/IfStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/IfStatement.java index 3e45436d036..3e14f8abd68 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/IfStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/IfStatement.java @@ -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; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Import.java b/j2k/src/org/jetbrains/jet/j2k/ast/Import.java index 854b2fa3534..f6172f6e9f0 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Import.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Import.java @@ -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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/InProjectionType.java b/j2k/src/org/jetbrains/jet/j2k/ast/InProjectionType.java index 17d2b63cc04..d3a825a3f92 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/InProjectionType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/InProjectionType.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.java b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.java index d49dc13c1e2..f26f8a6a82f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Initializer.java @@ -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 modifiers) { - myBlock = block; - myModifiers = modifiers; - } + public Initializer(Block block, Set modifiers) { + myBlock = block; + myModifiers = modifiers; + } - @NotNull - @Override - public String toKotlin() { - return myBlock.toKotlin(); - } + @NotNull + @Override + public String toKotlin() { + return myBlock.toKotlin(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/IsOperator.java b/j2k/src/org/jetbrains/jet/j2k/ast/IsOperator.java index 98c6c3abcac..d6162a0792f 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/IsOperator.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/IsOperator.java @@ -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() + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/LabelStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/LabelStatement.java index 9908938b4d1..421e851196b 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/LabelStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/LabelStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/LiteralExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/LiteralExpression.java index 451f22757d0..230f3252eb6 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/LiteralExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/LiteralExpression.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.java b/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.java index 0c561827a18..679cb5f13d6 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/LocalVariable.java @@ -8,29 +8,30 @@ import java.util.Set; * @author ignatov */ public class LocalVariable extends Expression { - private final Identifier myIdentifier; - private final Set myModifiersSet; - private final Type myType; - private final Expression myInitializer; + private final Identifier myIdentifier; + private final Set myModifiersSet; + private final Type myType; + private final Expression myInitializer; - public LocalVariable(Identifier identifier, Set modifiersSet, Type type, Expression initializer) { - myIdentifier = identifier; - myModifiersSet = modifiersSet; - myType = type; - myInitializer = initializer; - } + public LocalVariable(Identifier identifier, Set 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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Member.java b/j2k/src/org/jetbrains/jet/j2k/ast/Member.java index ade895c672c..e0bb5f07c5d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Member.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Member.java @@ -8,23 +8,24 @@ import java.util.Set; * @author ignatov */ public abstract class Member extends Node implements IMember { - Set myModifiers; + Set 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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.java index c8e64c21e2e..c139212fd76 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/MethodCallExpression.java @@ -9,34 +9,36 @@ import java.util.List; * @author ignatov */ public class MethodCallExpression extends Expression { - private final Expression myMethodCall; - private final List myArguments; - private final List myConversions; - private final boolean myIsResultNullable; - private final List myTypeParameters; + private final Expression myMethodCall; + private final List myArguments; + private final List myConversions; + private final boolean myIsResultNullable; + private final List myTypeParameters; - public MethodCallExpression(Expression methodCall, List arguments, List typeParameters) { - this(methodCall, arguments, AstUtil.createListWithEmptyString(arguments), false, typeParameters); - } + public MethodCallExpression(Expression methodCall, List arguments, List typeParameters) { + this(methodCall, arguments, AstUtil.createListWithEmptyString(arguments), false, typeParameters); + } - public MethodCallExpression(Expression methodCall, List arguments, List conversions, boolean nullable, List typeParameters) { - myMethodCall = methodCall; - myArguments = arguments; - myConversions = conversions; - myIsResultNullable = nullable; - myTypeParameters = typeParameters; - } + public MethodCallExpression(Expression methodCall, List arguments, List conversions, boolean nullable, List 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 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 applyConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myArguments), myConversions); + return myMethodCall.toKotlin() + typeParamsToKotlin + "(" + AstUtil.join(applyConversions, COMMA_WITH_SPACE) + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.java b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.java index 8329fcbc02a..3ccccefc0ff 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Modifier.java @@ -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"; } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.java index 35b4d0239cd..f4ff15137a2 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/NewClassExpression.java @@ -10,37 +10,38 @@ import java.util.List; * @author ignatov */ public class NewClassExpression extends Expression { - private final Element myName; - private final List myArguments; - private Expression myQualifier; - private List myConversions; - @Nullable - private AnonymousClass myAnonymousClass = null; + private final Element myName; + private final List myArguments; + private Expression myQualifier; + private List myConversions; + @Nullable + private AnonymousClass myAnonymousClass = null; - private NewClassExpression(Element name, List arguments) { - myName = name; - myQualifier = EMPTY_EXPRESSION; - myArguments = arguments; - myConversions = AstUtil.createListWithEmptyString(arguments); - } + private NewClassExpression(Element name, List arguments) { + myName = name; + myQualifier = EMPTY_EXPRESSION; + myArguments = arguments; + myConversions = AstUtil.createListWithEmptyString(arguments); + } - public NewClassExpression(@NotNull Expression qualifier, @NotNull Element name, @NotNull List arguments, - @NotNull List conversions, @Nullable AnonymousClass anonymousClass) { - this(name, arguments); - myQualifier = qualifier; - myConversions = conversions; - myAnonymousClass = anonymousClass; - } + public NewClassExpression(@NotNull Expression qualifier, @NotNull Element name, @NotNull List arguments, + @NotNull List 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 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 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 + ")"; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Node.java b/j2k/src/org/jetbrains/jet/j2k/ast/Node.java index a42fb06cca0..6f81967e2e1 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Node.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Node.java @@ -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 ONLY_KOTLIN_KEYWORDS = new HashSet(Arrays.asList( - "package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This" - )); + @NotNull + final static Set ONLY_KOTLIN_KEYWORDS = new HashSet(Arrays.asList( + "package", "as", "type", "val", "var", "fun", "is", "in", "object", "when", "trait", "This" + )); - @NotNull - public final static Set PRIMITIVE_TYPES = new HashSet(Arrays.asList( - "double", "float", "long", "int", "short", "byte", "boolean", "char" - )); + @NotNull + public final static Set PRIMITIVE_TYPES = new HashSet(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"; } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/OutProjectionType.java b/j2k/src/org/jetbrains/jet/j2k/ast/OutProjectionType.java index dbe75210fb7..fd32b87b9e4 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/OutProjectionType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/OutProjectionType.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.java b/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.java index a0258a173de..d424b09b921 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Parameter.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.java b/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.java index 9528a74e103..6b802c223d9 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ParameterList.java @@ -9,15 +9,15 @@ import java.util.List; * @author ignatov */ public class ParameterList extends Expression { - private final List myParameters; + private final List myParameters; - public ParameterList(List parameters) { - myParameters = parameters; - } + public ParameterList(List 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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ParenthesizedExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ParenthesizedExpression.java index 8a5ac18447c..2c9fa62937e 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ParenthesizedExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ParenthesizedExpression.java @@ -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() + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.java index d99481c305d..b0f265fdcc9 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/PolyadicExpression.java @@ -9,21 +9,21 @@ import java.util.List; * @author ignatov */ public class PolyadicExpression extends Expression { - private final List myExpressions; - private final String myToken; - private final List myConversions; + private final List myExpressions; + private final String myToken; + private final List myConversions; - public PolyadicExpression(List expressions, String token, List conversions) { - super(); - myExpressions = expressions; - myToken = token; - myConversions = conversions; - } + public PolyadicExpression(List expressions, String token, List conversions) { + super(); + myExpressions = expressions; + myToken = token; + myConversions = conversions; + } - @NotNull - @Override - public String toKotlin() { - List expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myExpressions), myConversions); - return AstUtil.join(expressionsWithConversions, SPACE + myToken + SPACE); - } + @NotNull + @Override + public String toKotlin() { + List expressionsWithConversions = AstUtil.applyConversions(AstUtil.nodesToKotlin(myExpressions), myConversions); + return AstUtil.join(expressionsWithConversions, SPACE + myToken + SPACE); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/PostfixOperator.java b/j2k/src/org/jetbrains/jet/j2k/ast/PostfixOperator.java index ffac99c0d93..56f6723ad62 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/PostfixOperator.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/PostfixOperator.java @@ -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; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/PrefixOperator.java b/j2k/src/org/jetbrains/jet/j2k/ast/PrefixOperator.java index f91f98bc837..e9b30591d53 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/PrefixOperator.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/PrefixOperator.java @@ -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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/PrimitiveType.java b/j2k/src/org/jetbrains/jet/j2k/ast/PrimitiveType.java index 9a84b467fa2..a2691ee428c 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/PrimitiveType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/PrimitiveType.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java index 4be89b2db69..7fbc95da4e8 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ReferenceElement.java @@ -9,20 +9,20 @@ import java.util.List; * @author ignatov */ public class ReferenceElement extends Element { - @NotNull - private final Identifier myReference; - @NotNull - private final List myTypes; + @NotNull + private final Identifier myReference; + @NotNull + private final List myTypes; - public ReferenceElement(@NotNull Identifier reference, @NotNull List types) { - myReference = reference; - myTypes = types; - } + public ReferenceElement(@NotNull Identifier reference, @NotNull List 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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ReturnStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ReturnStatement.java index bf2e7ca6579..196dc22ad25 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ReturnStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ReturnStatement.java @@ -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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/StarProjectionType.java b/j2k/src/org/jetbrains/jet/j2k/ast/StarProjectionType.java index 145b322e2d3..dd37021bf18 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/StarProjectionType.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/StarProjectionType.java @@ -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 g2 = new G(""); - return STAR; - } + @NotNull + @Override + public String toKotlin() { + G g = new G(""); + G g2 = new G(""); + return STAR; + } } -class G { - public G(T t) { - } +class G { + public G(T t) { + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Statement.java b/j2k/src/org/jetbrains/jet/j2k/ast/Statement.java index b96d026c086..a2d12bf1103 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Statement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Statement.java @@ -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; + } } - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/SuperExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/SuperExpression.java index 5793efb0e05..7e29be87188 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/SuperExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/SuperExpression.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/SureCallChainExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/SureCallChainExpression.java index f570fcce81c..9579e819daf 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/SureCallChainExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/SureCallChainExpression.java @@ -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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/SwitchContainer.java b/j2k/src/org/jetbrains/jet/j2k/ast/SwitchContainer.java index 363a93b7bfc..1a027f1845a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/SwitchContainer.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/SwitchContainer.java @@ -9,19 +9,19 @@ import java.util.List; * @author ignatov */ public class SwitchContainer extends Statement { - private final Expression myExpression; - private final List myCaseContainers; + private final Expression myExpression; + private final List myCaseContainers; - public SwitchContainer(final Expression expression, final List caseContainers) { - myExpression = expression; - myCaseContainers = caseContainers; - } + public SwitchContainer(final Expression expression, final List 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 + + "}"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/SwitchLabelStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/SwitchLabelStatement.java index 78afed2d3e7..937824476fe 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/SwitchLabelStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/SwitchLabelStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/SynchronizedStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/SynchronizedStatement.java index 63d3150b957..8a0685f03e5 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/SynchronizedStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/SynchronizedStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ThisExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/ThisExpression.java index e3bba0d5997..3c35a44ea3d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ThisExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ThisExpression.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/ThrowStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/ThrowStatement.java index 298650d1f3c..58be105b6f6 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/ThrowStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/ThrowStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java index aed3f075e3d..3c0172912ef 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Trait.java @@ -7,18 +7,18 @@ import java.util.Set; * @author ignatov */ public class Trait extends Class { - public Trait(Identifier name, Set modifiers, List typeParameters, List extendsTypes, - List baseClassParams, List implementsTypes, List members) { - super(name, modifiers, typeParameters, extendsTypes, baseClassParams, implementsTypes, getMembers(members)); - TYPE = "trait"; - } + public Trait(Identifier name, Set modifiers, List typeParameters, List extendsTypes, + List baseClassParams, List implementsTypes, List 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; + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TryStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/TryStatement.java index d9ae141327e..fbf0a6f94a7 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TryStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TryStatement.java @@ -9,22 +9,22 @@ import java.util.List; * @author ignatov */ public class TryStatement extends Statement { - private final Block myBlock; - private final List myCatches; - private final Block myFinallyBlock; + private final Block myBlock; + private final List myCatches; + private final Block myFinallyBlock; - public TryStatement(Block block, List catches, Block finallyBlock) { - myBlock = block; - myCatches = catches; - myFinallyBlock = finallyBlock; - } + public TryStatement(Block block, List 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()); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Type.java b/j2k/src/org/jetbrains/jet/j2k/ast/Type.java index d0182cbb633..b22ee70eb84 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/Type.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/Type.java @@ -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; + } } - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeCastExpression.java b/j2k/src/org/jetbrains/jet/j2k/ast/TypeCastExpression.java index ddd82b0dad4..e3cc32a7195 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeCastExpression.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeCastExpression.java @@ -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() + ")"; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.java b/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.java index 542b2781d2a..49627720bcc 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeElement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.java b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.java index 9e9b07c2ad2..8dd7cc0061d 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/TypeParameter.java @@ -8,30 +8,32 @@ import java.util.List; * @author ignatov */ public class TypeParameter extends Element { - private final Identifier myName; - private final List myExtendsTypes; + private final Identifier myName; + private final List myExtendsTypes; - public TypeParameter(Identifier name, List extendsTypes) { - myName = name; - myExtendsTypes = extendsTypes; - } + public TypeParameter(Identifier name, List 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(); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/VarArg.java b/j2k/src/org/jetbrains/jet/j2k/ast/VarArg.java index 8ddbc697a2d..38d1b821849 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/VarArg.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/VarArg.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/WhileStatement.java b/j2k/src/org/jetbrains/jet/j2k/ast/WhileStatement.java index 8502370c5a1..955cac34e1a 100644 --- a/j2k/src/org/jetbrains/jet/j2k/ast/WhileStatement.java +++ b/j2k/src/org/jetbrains/jet/j2k/ast/WhileStatement.java @@ -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(); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/util/AstUtil.java b/j2k/src/org/jetbrains/jet/j2k/util/AstUtil.java index fade672d1e9..3a715a101fd 100644 --- a/j2k/src/org/jetbrains/jet/j2k/util/AstUtil.java +++ b/j2k/src/org/jetbrains/jet/j2k/util/AstUtil.java @@ -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 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 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 nodesToKotlin(@NotNull List nodes) { - List result = new LinkedList(); - 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 List createListWithEmptyString(@NotNull final List arguments) { - final List conversions = new LinkedList(); - //noinspection UnusedDeclaration - for (T argument : arguments) conversions.add(""); - return conversions; - } - - @NotNull - public static List applyConversions(@NotNull List first, @NotNull List second) { - List result = new LinkedList(); - 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 nodes, final String delimiter) { + return join(nodesToKotlin(nodes), delimiter); + } - @NotNull - public static T getOrElse(@NotNull Map map, @NotNull T e, @NotNull T orElse) { - if (map.containsKey(e)) - return map.get(e); - return orElse; - } + public static String join(@NotNull final List 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 nodesToKotlin(@NotNull List nodes) { + List result = new LinkedList(); + 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 List createListWithEmptyString(@NotNull final List arguments) { + final List conversions = new LinkedList(); + //noinspection UnusedDeclaration + for (T argument : arguments) conversions.add(""); + return conversions; + } + + @NotNull + public static List applyConversions(@NotNull List first, @NotNull List second) { + List result = new LinkedList(); + 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 getOrElse(@NotNull Map 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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.java index f604447da89..fd433a7914c 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ClassVisitor.java @@ -11,20 +11,20 @@ import java.util.Set; * @author ignatov */ public class ClassVisitor extends JavaRecursiveElementVisitor { - private final Set myClassIdentifiers; + private final Set myClassIdentifiers; - public ClassVisitor() { - myClassIdentifiers = new HashSet(); - } + public ClassVisitor() { + myClassIdentifiers = new HashSet(); + } - @NotNull - public Set getClassIdentifiers() { - return new HashSet(myClassIdentifiers); - } + @NotNull + public Set getClassIdentifiers() { + return new HashSet(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); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java index 1bab193181b..8da473b81be 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/Dispatcher.java @@ -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; + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java index 78cccb320bc..12f7591b98e 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ElementVisitor.java @@ -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 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 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()) + ); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java index ff754c17393..5cd5c247f83 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.java @@ -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 typeParameters = reference != null ? typesToTypeList(reference.getTypeParameters()) : Collections.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 typeParameters = reference != null + ? typesToTypeList(reference.getTypeParameters()) + : Collections.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) + ); + } } \ No newline at end of file diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java index 1f184e161e2..e14a2013711 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitorForDirectObjectInheritors.java @@ -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; - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java index 48ef77f5e86..4941ab24324 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.java @@ -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 forStatements = new LinkedList(); - 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 switchBodyToCases(@Nullable final PsiCodeBlock body) { - final List> cases = splitToCases(body); - final List allSwitchStatements = body != null ? Arrays.asList(body.getStatements()) : Collections.emptyList(); - - List result = new LinkedList(); - List pendingLabels = new LinkedList(); - int i = 0; - for (List 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 slice = ls.subList(1, ls.size()); - - if (!containsBreak(slice)) { - List statements = statementsToStatementList(slice); - statements.addAll( - statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size())) - ); - result.add(new CaseContainer(pendingLabels, statements)); - pendingLabels = new LinkedList(); - } else { - result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice))); - pendingLabels = new LinkedList(); + @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 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 getAllToNextBreak(@NotNull final List allStatements, final int start) { - List result = new LinkedList(); - 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 forStatements = new LinkedList(); + 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 switchBodyToCases(@Nullable final PsiCodeBlock body) { + final List> cases = splitToCases(body); + final List allSwitchStatements = body != null + ? Arrays.asList(body.getStatements()) + : Collections.emptyList(); + + List result = new LinkedList(); + List pendingLabels = new LinkedList(); + int i = 0; + for (List 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 slice = ls.subList(1, ls.size()); + + if (!containsBreak(slice)) { + List statements = statementsToStatementList(slice); + statements.addAll( + statementsToStatementList(getAllToNextBreak(allSwitchStatements, i + ls.size())) + ); + result.add(new CaseContainer(pendingLabels, statements)); + pendingLabels = new LinkedList(); + } + else { + result.add(new CaseContainer(pendingLabels, statementsToStatementList(slice))); + pendingLabels = new LinkedList(); + } + } + 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> splitToCases(@Nullable final PsiCodeBlock body) { - List> cases = new LinkedList>(); - List currentCaseStatements = new LinkedList(); - 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(); - } + private static boolean containsBreak(@NotNull final List slice) { + for (PsiStatement s : slice) + if (s instanceof PsiBreakStatement) { + return true; + } + return false; + } + + @NotNull + private static List getAllToNextBreak(@NotNull final List allStatements, final int start) { + List result = new LinkedList(); + 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 catches = new LinkedList(); - for (int i = 0; i < statement.getCatchBlocks().length; i++) { - catches.add(new CatchStatement( - parameterToParameter(statement.getCatchBlockParameters()[i]), - blockToBlock(statement.getCatchBlocks()[i], true) - )); + return result; } - myResult = new TryStatement( - blockToBlock(statement.getTryBlock(), true), - catches, - blockToBlock(statement.getFinallyBlock(), true) - ); - } + @NotNull + private static List> splitToCases(@Nullable final PsiCodeBlock body) { + List> cases = new LinkedList>(); + List currentCaseStatements = new LinkedList(); + 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(); + } + } + 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 catches = new LinkedList(); + for (int i = 0; i < statement.getCatchBlocks().length; i++) { + catches.add(new CatchStatement( + parameterToParameter(statement.getCatchBlockParameters()[i]), + blockToBlock(statement.getCatchBlocks()[i], true) + )); + } + + 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 + ); + } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.java index c7a8e7bc42a..aec4e406f81 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/SuperVisitor.java @@ -10,32 +10,33 @@ import java.util.HashSet; * @author ignatov */ public class SuperVisitor extends JavaRecursiveElementVisitor { - @NotNull - private final HashSet myResolvedSuperCallParameters; + @NotNull + private final HashSet myResolvedSuperCallParameters; - public SuperVisitor() { - myResolvedSuperCallParameters = new HashSet(); - } - - @NotNull - public HashSet 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(); + } + + @NotNull + public HashSet 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; - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java index c077ced52b5..dd1a83a8959 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/ThisVisitor.java @@ -10,28 +10,30 @@ import java.util.HashSet; * @author ignatov */ public class ThisVisitor extends JavaRecursiveElementVisitor { - @NotNull - private final HashSet myResolvedConstructors = new HashSet(); + @NotNull + private final HashSet myResolvedConstructors = new HashSet(); - @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; - } } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java index 4d71752d174..8263b8af421 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java @@ -17,160 +17,176 @@ import static org.jetbrains.jet.j2k.Converter.typesToTypeList; * @author ignatov */ public class TypeVisitor extends PsiTypeVisitor { - 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 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 createRawTypesForResolvedReference(@NotNull PsiClassType classType) { - final List typeParams = new LinkedList(); - 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 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 createRawTypesForResolvedReference(@NotNull PsiClassType classType) { + final List typeParams = new LinkedList(); + 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); + } } diff --git a/j2k/test/org/jetbrains/jet/j2k/TestCaseBuilder.java b/j2k/test/org/jetbrains/jet/j2k/TestCaseBuilder.java index 275f70a012d..d6dbeda3d91 100644 --- a/j2k/test/org/jetbrains/jet/j2k/TestCaseBuilder.java +++ b/j2k/test/org/jetbrains/jet/j2k/TestCaseBuilder.java @@ -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 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 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 subdirs = Arrays.asList(files); + Collections.sort(subdirs); + for (File subdir : subdirs) { + suite.addTest(suiteForDirectory(baseDataDir, dataPath + "/" + subdir.getName(), recursive, filter, factory)); + } + } + List 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; - } }