#162: conflicts resolving

Author: includealex

src/main/kotlin/org/polystat/j2eo/eotree/EOMetaObjects.kt

@@ -12,7 +12,7 @@ import arrow.core.Option
  */
 fun EOSeqCall(vararg statements: EOCopy): EOBndExpr = EOSeqCall(statements.toList())
 
-// TODO: maybe expand list type from List<EOCopy> to List<EOExpr>?
+// @todo #165:90m maybe we should expand list type from List<EOCopy> to List<EOExpr>?
 /**
  * Generator of seq > @ blocks.
  */

src/main/kotlin/org/polystat/j2eo/translator/Expressions.kt

@@ -181,7 +181,7 @@ fun mapParenthesized(expr: Parenthesized, name: String, context: Context): List<
     ) + mapExpression(expr.expression, parExprName, context)
 }
 
-// addition of support for type
+// @todo #165:90m Support for type should be added
 fun mapThis(expr: This, name: String, context: Context): EOBndExpr {
     return EOBndExpr(
         EOObject(
@@ -290,8 +290,13 @@ fun mapUnaryPostfix(expr: UnaryPostfix, name: String, context: Context): List<EO
     ) + mapExpression(expr.operand, operandName, context)
 }
 
-// Addition of automatic casting for primitive types is needed
-// population with all Java binary operators is needed
+// @todo #165:90m Add automatic casting for primitive types
+
+// @todo #165:90m Populate with all Java binary operators
+
+// @todo #165:90m in val function double check is needed for some TokenCodes:
+// NonEqual, DoubleVertical, DoubleAmpersand, Ampersand, Vertical, Caret
+
 fun mapBinary(expr: Binary, name: String, context: Context): List<EOBndExpr> {
     val function = when (expr.operator) {
         TokenCode.Plus -> "add"
@@ -315,14 +320,14 @@ fun mapBinary(expr: Binary, name: String, context: Context): List<EOBndExpr> {
         TokenCode.LeftShiftAssign -> "shift_l_equal"
         TokenCode.ArithmRightShift -> "shift_u"
         TokenCode.ArithmRightShiftAssign -> "shift_u_equal"
-        TokenCode.NonEqual -> "not_eq" /* double check is needed */
-        TokenCode.DoubleVertical -> "or" /* double check is needed */
-        TokenCode.DoubleAmpersand -> "and" /* double check is needed */
-        TokenCode.Ampersand -> "bit_and" /* double check is needed */
-        TokenCode.Vertical -> "bit_or" /* double check is needed */
+        TokenCode.NonEqual -> "not_eq"
+        TokenCode.DoubleVertical -> "or"
+        TokenCode.DoubleAmpersand -> "and"
+        TokenCode.Ampersand -> "bit_and"
+        TokenCode.Vertical -> "bit_or"
         TokenCode.VerticalAssign -> "or_write" /* FIXME */
         TokenCode.AmpersandAssign -> "and_write" /* FIXME */
-        TokenCode.Caret -> "bit_xor" /* double check is needed */
+        TokenCode.Caret -> "bit_xor"
         else ->
             "binary_op_placeholder" // FIXME
         // throw IllegalArgumentException("Binary operation ${expr.operator} is not supported")

src/main/kotlin/org/polystat/j2eo/translator/MethodInvocations.kt

@@ -70,7 +70,7 @@ fun trueMethodInvocationName(name: String): List<String> {
     }
 }
 
-// Creation of state object to store binding of expression is needed
+// @todo #165:90m Create state object to store binding of expression
 fun mapMethodInvocation(methodInvocation: MethodInvocation, name: String, context: Context): List<EOBndExpr> {
     // require(!methodInvocation.superSign) { "Super sign isn't supported yet" }
     /* FIXME (NOW PARTIALLY SUPPORTED) */

src/main/kotlin/org/polystat/j2eo/translator/Statements.kt

@@ -185,8 +185,9 @@ fun mapIfThenElseStatement(rn: IfThenElse, name: String, context: Context): List
  *
  * conditionExpr and statement are mapped into separate objects.
  *
- * We should check if we can use iterator inside of statement.
  */
+
+//  @todo #165:90m We should check if we can use iterator inside of statement
 fun mapWhileStatement(wh: While, name: String, context: Context): List<EOBndExpr> {
     val emptyName = context.genUniqueEntityName("empty")
     val condName = context.genUniqueEntityName(wh.condition)

src/main/kotlin/org/polystat/j2eo/translator/Translator.kt

@@ -29,10 +29,10 @@ class Translator(val relativePath: Path) {
                     " is not supported"
             )
     }
-
+    // @todo #165:30m We should add license to EOLicense()
     fun mapPackage(pkg: Package, context: Context): EOProgram {
         return EOProgram(
-            EOLicense(), // is license added?
+            EOLicense(),
             EOMetas(
                 Some(pkg.compoundName.names.joinToString(".")),
                 ArrayList()

src/main/kotlin/org/polystat/j2eo/treeMapper/TreeMappings.kt

@@ -38,12 +38,13 @@ fun TypeDeclarationContext.toTopLevelComponent(): TopLevelComponent? =
         null // throw java.lang.Exception("Cannot translate") // FIXME
     }
 
+// @todo #165:90m We should implement this.typeList(1) for PERMITS (Java 17)
 fun ClassDeclarationContext.toClassDeclaration(): ClassDeclaration =
     NormalClassDeclaration(
         identifier().toToken(),
         typeParameters()?.toTypeParameters(),
         typeType()?.toType(),
-        typeList(0)?.toTypeList(), // TODO: use this.typeList(1) for PERMITS (Java 17)
+        typeList(0)?.toTypeList(),
         classBody().toDeclarations()
     )
 
@@ -187,12 +188,17 @@ fun TypeTypeOrVoidContext.toType(): Type? = typeType()?.toType()
 fun BlockContext.toDeclaration(isStatic: TerminalNode?): List<Declaration> =
     listOf(ClassInitializer(this.toBlock(), isStatic != null))
 
+// @todo #165:90m return Block(null, ...). Is it always null?
 fun BlockContext.toBlock(): Block {
     val blockStmntsLst = ArrayList(this.blockStatement().map { it.toBlockStatement() })
     val blockStmnts = BlockStatements(blockStmntsLst.removeFirstOrNull())
     blockStmntsLst.forEach { blockStmnts.add(it) }
     blockStmnts.blockStatements.removeIf { it == null }
+<<<<<<< HEAD
     return Block(null /*not always null? */, blockStmnts)
+=======
+    return Block(null, blockStmnts)
+>>>>>>> master
 }
 
 fun Declaration.toBlockStatement(): BlockStatement = BlockStatement(this)
@@ -465,6 +471,7 @@ fun ArgumentsContext.toArgList(): ArgumentList {
     }
 }
 
+// @todo #165:60m Maybe type arguments are somewhere else?
 fun MethodCallContext.toExpression(expr: Expression?): Expression {
     val exprLst = if (expressionList() == null)
         listOf()
@@ -476,7 +483,7 @@ fun MethodCallContext.toExpression(expr: Expression?): Expression {
     return MethodInvocation(
         expr,
         SUPER() != null,
-        null, // TODO: type arguments are somewhere else
+        null,
         identifier()?.toToken()
             ?: if (SUPER() != null) { Token(TokenCode.Super, "super") } else { null }
             ?: if (THIS() != null) { Token(TokenCode.This, "this") } else { null },

src/main/kotlin/org/polystat/j2eo/util/Naming.kt

@@ -7,6 +7,6 @@ fun String.eoClassName(): String = genClassName(this)
 fun genClassName(javaName: String): String =
     "class__$javaName"
 
-// We should introduce logic considering packages and classes
+// @todo #165:90m introduce logic considering packages and classes
 fun CompoundName.eoClassCompoundName(): CompoundName =
     CompoundName(names.dropLast(1) + names.last().eoClassName())

src/main/kotlin/org/polystat/j2eo/util/StaticGenerator.kt

@@ -13,12 +13,14 @@ import tree.Declaration.NormalClassDeclaration
 /**
  * Maps all static class members to EO bindings, skipping non-static ones.
  */
+// @todo #165:90m dec is ClassDeclaration is not always true
 fun generateStatic(clsDec: NormalClassDeclaration, context: Context): List<EOBndExpr> {
     return clsDec.body.declarations
         .filter { dec: Declaration ->
             dec.modifiers?.modifiers?.modifiers?.find { it == TokenCode.Static } != null ||
                 dec is ConstructorDeclaration ||
                 dec is ClassDeclaration /* FIXME (IT'S NOT ALWAYS TRUE) */
+                dec is ClassDeclaration
         }
         .map { mapClassDeclaration(it, context) }
         .flatten()

src/test/resources/test_ready/ch_8_classes/sec_8_4_method_declarations/sec_8_4_3_method_modifiers/sec_8_4_3_4_native_methods/SampleTest.java

@@ -1,3 +1,4 @@
+// @todo #165:90m method() is left for the future
 public class SimpleNativeMethod {
 
 	static native void method();