From 880be759b7297176d571c06df08c66272e48cc6b Mon Sep 17 00:00:00 2001 From: Graham Date: Wed, 5 Aug 2020 12:45:20 +0100 Subject: [PATCH] Use smart casts in the AST deobfuscator Many of the old is/as calls were left over from the original Java code. Signed-off-by: Graham --- .../deob/ast/transform/AddSubTransformer.kt | 8 +- .../transform/BinaryExprOrderTransformer.kt | 4 +- .../deob/ast/transform/BitMaskTransformer.kt | 45 +++++----- .../ast/transform/ComplementTransformer.kt | 11 +-- .../deob/ast/transform/EncloseTransformer.kt | 83 +++++++++---------- .../transform/ForLoopConditionTransformer.kt | 9 +- .../deob/ast/transform/GlTransformer.kt | 54 ++++++------ .../deob/ast/transform/IdentityTransformer.kt | 14 ++-- .../deob/ast/transform/IfElseTransformer.kt | 70 ++++++++-------- .../ast/transform/IncrementTransformer.kt | 11 ++- .../dev/openrs2/deob/ast/util/ExprUtils.kt | 63 +++++++------- 11 files changed, 187 insertions(+), 185 deletions(-) diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt index 65dde0a6b8..19f2f21aae 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt @@ -88,14 +88,14 @@ class AddSubTransformer : Transformer() { } private fun Expression.isNegative(): Boolean { - return when { - isUnaryExpr -> asUnaryExpr().operator == UnaryExpr.Operator.MINUS - isIntegerLiteralExpr -> when (val n = asIntegerLiteralExpr().asNumber()) { + return when (this) { + is UnaryExpr -> operator == UnaryExpr.Operator.MINUS + is IntegerLiteralExpr -> when (val n = asNumber()) { IntegerLiteralExpr.MAX_31_BIT_UNSIGNED_VALUE_AS_LONG -> false is Int -> n < 0 else -> error("Invalid IntegerLiteralExpr type") } - isLongLiteralExpr -> when (val n = asLongLiteralExpr().asNumber()) { + is LongLiteralExpr -> when (val n = asNumber()) { LongLiteralExpr.MAX_63_BIT_UNSIGNED_VALUE_AS_BIG_INTEGER -> false is Long -> n < 0 else -> error("Invalid LongLiteralExpr type") diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt index b1c5827cd1..47127484de 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt @@ -3,6 +3,8 @@ package dev.openrs2.deob.ast.transform import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.Expression +import com.github.javaparser.ast.expr.LiteralExpr +import com.github.javaparser.ast.expr.ThisExpr import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.util.flip @@ -32,5 +34,5 @@ class BinaryExprOrderTransformer : Transformer() { } private val Expression.isLiteralOrThisExpr: Boolean - get() = isLiteralExpr || isThisExpr + get() = this is LiteralExpr || this is ThisExpr } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt index 5933491be0..48632086e5 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt @@ -3,11 +3,11 @@ package dev.openrs2.deob.ast.transform import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.IntegerLiteralExpr +import com.github.javaparser.ast.expr.LongLiteralExpr import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.util.checkedAsInt import dev.openrs2.deob.ast.util.checkedAsLong -import dev.openrs2.deob.ast.util.isIntegerOrLongLiteral import dev.openrs2.deob.ast.util.toLongLiteralExpr import dev.openrs2.deob.ast.util.walk import javax.inject.Singleton @@ -17,43 +17,46 @@ class BitMaskTransformer : Transformer() { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { unit.walk { expr: BinaryExpr -> val shiftOp = expr.operator - val left = expr.left + val bitwiseExpr = expr.left val shamtExpr = expr.right - if (shiftOp !in SHIFT_OPS || !left.isBinaryExpr || !shamtExpr.isIntegerLiteralExpr) { + if (shiftOp !in SHIFT_OPS || bitwiseExpr !is BinaryExpr || shamtExpr !is IntegerLiteralExpr) { return@walk } - val bitwiseExpr = left.asBinaryExpr() val bitwiseOp = bitwiseExpr.operator val argExpr = bitwiseExpr.left var maskExpr = bitwiseExpr.right - if (bitwiseOp !in BITWISE_OPS || !maskExpr.isIntegerOrLongLiteral()) { + if (bitwiseOp !in BITWISE_OPS) { return@walk } - val shamt = shamtExpr.asIntegerLiteralExpr().checkedAsInt() - if (maskExpr.isIntegerLiteralExpr) { - var mask = maskExpr.asIntegerLiteralExpr().checkedAsInt() + val shamt = shamtExpr.checkedAsInt() + when (maskExpr) { + is IntegerLiteralExpr -> { + var mask = maskExpr.checkedAsInt() - mask = when (shiftOp) { - BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt - BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt - else -> error("Invalid shiftOp") + mask = when (shiftOp) { + BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt + BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt + else -> error("Invalid shiftOp") + } + + maskExpr = IntegerLiteralExpr(mask.toString()) } + is LongLiteralExpr -> { + var mask = maskExpr.checkedAsLong() - maskExpr = IntegerLiteralExpr(mask.toString()) - } else { - var mask = maskExpr.asLongLiteralExpr().checkedAsLong() + mask = when (shiftOp) { + BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt + BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt + else -> error("Invalid shiftOp") + } - mask = when (shiftOp) { - BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt - BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt - else -> error("Invalid shiftOp") + maskExpr = mask.toLongLiteralExpr() } - - maskExpr = mask.toLongLiteralExpr() + else -> return@walk } expr.replace(BinaryExpr(BinaryExpr(argExpr.clone(), shamtExpr.clone(), shiftOp), maskExpr, bitwiseOp)) diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt index 79a19e5ee5..054a5d6724 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt @@ -4,6 +4,7 @@ import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.IntegerLiteralExpr +import com.github.javaparser.ast.expr.LongLiteralExpr import com.github.javaparser.ast.expr.UnaryExpr import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup @@ -34,7 +35,7 @@ class ComplementTransformer : Transformer() { private companion object { private fun Expression.isComplement(): Boolean { - return isUnaryExpr && asUnaryExpr().operator == UnaryExpr.Operator.BITWISE_COMPLEMENT + return this is UnaryExpr && operator == UnaryExpr.Operator.BITWISE_COMPLEMENT } private fun Expression.isComplementOrLiteral(): Boolean { @@ -53,10 +54,10 @@ class ComplementTransformer : Transformer() { } private fun Expression.complement(): Expression { - return when { - isUnaryExpr -> asUnaryExpr().expression - isIntegerLiteralExpr -> IntegerLiteralExpr(asIntegerLiteralExpr().checkedAsInt().inv().toString()) - isLongLiteralExpr -> asLongLiteralExpr().checkedAsLong().inv().toLongLiteralExpr() + return when (this) { + is UnaryExpr -> expression + is IntegerLiteralExpr -> IntegerLiteralExpr(checkedAsInt().inv().toString()) + is LongLiteralExpr -> checkedAsLong().inv().toLongLiteralExpr() else -> throw IllegalArgumentException() } } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt index 672ed8d691..ffd3bc7cc1 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt @@ -1,9 +1,19 @@ package dev.openrs2.deob.ast.transform import com.github.javaparser.ast.CompilationUnit +import com.github.javaparser.ast.expr.ArrayAccessExpr +import com.github.javaparser.ast.expr.ArrayCreationExpr +import com.github.javaparser.ast.expr.AssignExpr import com.github.javaparser.ast.expr.BinaryExpr +import com.github.javaparser.ast.expr.CastExpr +import com.github.javaparser.ast.expr.ConditionalExpr import com.github.javaparser.ast.expr.EnclosedExpr import com.github.javaparser.ast.expr.Expression +import com.github.javaparser.ast.expr.FieldAccessExpr +import com.github.javaparser.ast.expr.InstanceOfExpr +import com.github.javaparser.ast.expr.MethodCallExpr +import com.github.javaparser.ast.expr.ObjectCreationExpr +import com.github.javaparser.ast.expr.UnaryExpr import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.util.walk @@ -45,12 +55,12 @@ class EncloseTransformer : Transformer() { companion object { fun from(expr: Expression): Op? { - return when { - expr.isArrayAccessExpr || expr.isFieldAccessExpr -> ACCESS_PARENS - expr.isMethodCallExpr || expr.isEnclosedExpr -> ACCESS_PARENS - expr.isUnaryExpr -> if (expr.asUnaryExpr().operator.isPostfix) POSTFIX else UNARY - expr.isCastExpr || expr.isObjectCreationExpr || expr.isArrayCreationExpr -> CAST_NEW - expr.isBinaryExpr -> when (expr.asBinaryExpr().operator) { + return when (expr) { + is ArrayAccessExpr, is FieldAccessExpr -> ACCESS_PARENS + is MethodCallExpr, is EnclosedExpr -> ACCESS_PARENS + is UnaryExpr -> if (expr.operator.isPostfix) POSTFIX else UNARY + is CastExpr, is ObjectCreationExpr, is ArrayCreationExpr -> CAST_NEW + is BinaryExpr -> when (expr.operator) { BinaryExpr.Operator.MULTIPLY -> MULTIPLICATIVE BinaryExpr.Operator.DIVIDE, BinaryExpr.Operator.REMAINDER -> MULTIPLICATIVE BinaryExpr.Operator.PLUS, BinaryExpr.Operator.MINUS -> ADDITIVE @@ -66,9 +76,9 @@ class EncloseTransformer : Transformer() { BinaryExpr.Operator.OR -> LOGICAL_OR else -> null } - expr.isInstanceOfExpr -> RELATIONAL - expr.isConditionalExpr -> TERNARY - expr.isAssignExpr -> ASSIGNMENT + is InstanceOfExpr -> RELATIONAL + is ConditionalExpr -> TERNARY + is AssignExpr -> ASSIGNMENT else -> null } } @@ -77,49 +87,34 @@ class EncloseTransformer : Transformer() { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { unit.walk { expr: Expression -> - when { - expr.isArrayAccessExpr -> { - val accessExpr = expr.asArrayAccessExpr() - encloseLeft(expr, accessExpr.name) - } - expr.isFieldAccessExpr -> { - encloseLeft(expr, expr.asFieldAccessExpr().scope) - } - expr.isMethodCallExpr -> { - expr.asMethodCallExpr().scope.ifPresent { scope -> + when (expr) { + is ArrayAccessExpr -> encloseLeft(expr, expr.name) + is FieldAccessExpr -> encloseLeft(expr, expr.scope) + is MethodCallExpr -> { + expr.scope.ifPresent { scope -> encloseLeft(expr, scope) } } - expr.isUnaryExpr -> { - val unaryExpr = expr.asUnaryExpr() - encloseRight(expr, unaryExpr.expression) - } - expr.isCastExpr -> { - encloseRight(expr, expr.asCastExpr().expression) - } - expr.isObjectCreationExpr -> { - expr.asObjectCreationExpr().scope.ifPresent { scope -> + is UnaryExpr -> encloseRight(expr, expr.expression) + is CastExpr -> encloseRight(expr, expr.expression) + is ObjectCreationExpr -> { + expr.scope.ifPresent { scope -> encloseLeft(expr, scope) } } - expr.isBinaryExpr -> { - val binaryExpr = expr.asBinaryExpr() - encloseLeft(expr, binaryExpr.left) - encloseRight(expr, binaryExpr.right) - } - expr.isInstanceOfExpr -> { - encloseLeft(expr, expr.asInstanceOfExpr().expression) + is BinaryExpr -> { + encloseLeft(expr, expr.left) + encloseRight(expr, expr.right) } - expr.isConditionalExpr -> { - val conditionalExpr = expr.asConditionalExpr() - encloseLeft(expr, conditionalExpr.condition) - encloseLeft(expr, conditionalExpr.thenExpr) - encloseRight(expr, conditionalExpr.elseExpr) + is InstanceOfExpr -> encloseLeft(expr, expr.expression) + is ConditionalExpr -> { + encloseLeft(expr, expr.condition) + encloseLeft(expr, expr.thenExpr) + encloseRight(expr, expr.elseExpr) } - expr.isAssignExpr -> { - val assignExpr = expr.asAssignExpr() - encloseLeft(expr, assignExpr.target) - encloseRight(expr, assignExpr.value) + is AssignExpr -> { + encloseLeft(expr, expr.target) + encloseRight(expr, expr.value) } } } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt index 347a969af3..fb6109b560 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt @@ -23,13 +23,10 @@ class ForLoopConditionTransformer : Transformer() { unit.walk { stmt: ForStmt -> val updatedExprs = stmt.update.mapNotNull { it.getUpdatedExpr() } - stmt.compare.ifPresent { compare -> - if (!compare.isBinaryExpr) { + stmt.compare.ifPresent { expr -> + if (expr !is BinaryExpr) { return@ifPresent - } - - val expr = compare.asBinaryExpr() - if (expr.hasSideEffects()) { + } else if (expr.hasSideEffects()) { return@ifPresent } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt index 3f13499899..96037743d9 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt @@ -9,13 +9,17 @@ import com.github.javaparser.ast.body.Parameter import com.github.javaparser.ast.body.TypeDeclaration import com.github.javaparser.ast.body.VariableDeclarator import com.github.javaparser.ast.expr.BinaryExpr +import com.github.javaparser.ast.expr.ConditionalExpr import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.FieldAccessExpr +import com.github.javaparser.ast.expr.IntegerLiteralExpr import com.github.javaparser.ast.expr.MethodCallExpr import com.github.javaparser.ast.expr.NameExpr import com.github.javaparser.ast.expr.SimpleName import com.github.javaparser.ast.type.PrimitiveType +import com.github.javaparser.resolution.types.ResolvedArrayType import com.github.javaparser.resolution.types.ResolvedPrimitiveType +import com.github.javaparser.resolution.types.ResolvedReferenceType import com.github.javaparser.resolution.types.ResolvedType import com.github.michaelbull.logging.InlineLogger import dev.openrs2.deob.ast.Library @@ -65,11 +69,11 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran } private fun transformFramebufferStatus(unit: CompilationUnit, expr: Expression) { - if (!expr.isIntegerLiteralExpr) { + if (expr !is IntegerLiteralExpr) { return } - val value = expr.asIntegerLiteralExpr().checkedAsInt() + val value = expr.checkedAsInt() if (value.toLong() != GL_FRAMEBUFFER_COMPLETE.value) { return } @@ -92,8 +96,8 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran private fun ResolvedType.isFollowedByOffset(): Boolean { return when { - isArray && asArrayType().componentType.isPrimitive -> true - isReferenceType && asReferenceType().qualifiedName == "java.lang.Object" -> true + this is ResolvedArrayType && componentType.isPrimitive -> true + this is ResolvedReferenceType && qualifiedName == "java.lang.Object" -> true else -> false } } @@ -164,11 +168,11 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran expr.scope.ifPresent { scope -> val type = scope.calculateResolvedType() - if (!type.isReferenceType) { + if (type !is ResolvedReferenceType) { return@ifPresent } - val name = type.asReferenceType().qualifiedName + val name = type.qualifiedName if (name in GL_CLASSES) { transformArguments(unit, expr) } @@ -235,16 +239,18 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran parameter: GlParameter, expr: Expression ) { - if (expr.isBinaryExpr) { - val binaryExpr = expr.asBinaryExpr() - transformExpr(unit, command, parameter, binaryExpr.left) - transformExpr(unit, command, parameter, binaryExpr.right) - } else if (expr.isConditionalExpr) { - val conditionalExpr = expr.asConditionalExpr() - transformExpr(unit, command, parameter, conditionalExpr.thenExpr) - transformExpr(unit, command, parameter, conditionalExpr.elseExpr) - } else if (expr.isIntegerLiteralExpr) { - transformIntegerLiteralExpr(unit, command, parameter, expr) + when (expr) { + is BinaryExpr -> { + transformExpr(unit, command, parameter, expr.left) + transformExpr(unit, command, parameter, expr.right) + } + is ConditionalExpr -> { + transformExpr(unit, command, parameter, expr.thenExpr) + transformExpr(unit, command, parameter, expr.elseExpr) + } + is IntegerLiteralExpr -> { + transformIntegerLiteralExpr(unit, command, parameter, expr) + } } } @@ -252,9 +258,9 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran unit: CompilationUnit, command: GlCommand, parameter: GlParameter, - expr: Expression + expr: IntegerLiteralExpr ) { - var value = expr.asIntegerLiteralExpr().checkedAsInt() + var value = expr.checkedAsInt() val group = parameter.group ?: return if (parameter.bitfield) { @@ -320,21 +326,21 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran private val FIELD_METHOD_COMPARATOR = Comparator> { a, b -> when { - a.isFieldDeclaration && !b.isFieldDeclaration -> -1 - !a.isFieldDeclaration && b.isFieldDeclaration -> 1 + a is FieldDeclaration && b !is FieldDeclaration -> -1 + a !is FieldDeclaration && b is FieldDeclaration -> 1 else -> 0 } } private fun BodyDeclaration<*>.getIntValue(): Int? { - if (!isFieldDeclaration) { + if (this !is FieldDeclaration) { return null } - val variable = asFieldDeclaration().variables.firstOrNull() ?: return null + val variable = variables.firstOrNull() ?: return null return variable.initializer.map { - if (it.isIntegerLiteralExpr) { - it.asIntegerLiteralExpr().checkedAsInt() + if (it is IntegerLiteralExpr) { + it.checkedAsInt() } else { null } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt index 2bb13db568..a57d96c47b 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt @@ -3,6 +3,8 @@ package dev.openrs2.deob.ast.transform import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.Expression +import com.github.javaparser.ast.expr.IntegerLiteralExpr +import com.github.javaparser.ast.expr.LongLiteralExpr import com.github.javaparser.ast.expr.UnaryExpr import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup @@ -47,17 +49,17 @@ class IdentityTransformer : Transformer() { } private fun Expression.isZero(): Boolean { - return when { - isIntegerLiteralExpr -> asIntegerLiteralExpr().asNumber() == 0 - isLongLiteralExpr -> asLongLiteralExpr().asNumber() == 0L + return when (this) { + is IntegerLiteralExpr -> asNumber() == 0 + is LongLiteralExpr -> asNumber() == 0L else -> false } } private fun Expression.isOne(): Boolean { - return when { - isIntegerLiteralExpr -> asIntegerLiteralExpr().asNumber() == 1 - isLongLiteralExpr -> asLongLiteralExpr().asNumber() == 1L + return when (this) { + is IntegerLiteralExpr -> asNumber() == 1 + is LongLiteralExpr -> asNumber() == 1L else -> false } } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt index 2240630aae..c6f95fec10 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt @@ -7,6 +7,7 @@ import com.github.javaparser.ast.stmt.BlockStmt import com.github.javaparser.ast.stmt.IfStmt import com.github.javaparser.ast.stmt.ReturnStmt import com.github.javaparser.ast.stmt.Statement +import com.github.javaparser.ast.stmt.ThrowStmt import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.util.countNots @@ -78,7 +79,7 @@ class IfElseTransformer : Transformer() { val notCondition = condition.not() if (notCondition.countNots() < condition.countNots()) { stmt.condition = notCondition - if (elseStmt.isIfStmt) { + if (elseStmt is IfStmt) { val block = BlockStmt() block.statements.add(elseStmt.clone()) stmt.thenStmt = block @@ -136,23 +137,19 @@ class IfElseTransformer : Transformer() { unit.walk { stmt: IfStmt -> stmt.elseStmt.ifPresent { elseStmt -> // match - if (!elseStmt.isBlockStmt) { + if (elseStmt !is BlockStmt) { return@ifPresent } - val blockStmt = elseStmt.asBlockStmt() - val statements = blockStmt.statements + val statements = elseStmt.statements if (statements.isEmpty()) { return@ifPresent } - val head = statements[0] - if (!head.isIfStmt) { + val ifStmt = statements[0] + if (ifStmt !is IfStmt) { return@ifPresent - } - - val ifStmt = head.asIfStmt() - if (ifStmt.elseStmt.isPresent) { + } else if (ifStmt.elseStmt.isPresent) { return@ifPresent } @@ -164,7 +161,7 @@ class IfElseTransformer : Transformer() { // rewrite val condition = ifStmt.condition.not() - val tail = blockStmt.clone() + val tail = elseStmt.clone() tail.statements.removeAt(0) elseStmt.replace(IfStmt(condition, tail, thenStmt.clone())) @@ -213,25 +210,28 @@ class IfElseTransformer : Transformer() { } private fun Statement.isIf(): Boolean { - return when { - isIfStmt -> true - isBlockStmt -> { - val stmts = asBlockStmt().statements - stmts.size == 1 && stmts[0].isIfStmt + return when (this) { + is IfStmt -> true + is BlockStmt -> { + val stmts = statements + stmts.size == 1 && stmts[0] is IfStmt } else -> false } } private fun Statement.getIf(): Statement { - if (isIfStmt) { - return clone() - } else if (isBlockStmt) { - val stmts = asBlockStmt().statements - if (stmts.size == 1) { - val head = stmts[0] - if (head.isIfStmt) { - return head.clone() + when (this) { + is IfStmt -> { + return clone() + } + is BlockStmt -> { + val stmts = statements + if (stmts.size == 1) { + val head = stmts[0] + if (head is IfStmt) { + return head.clone() + } } } } @@ -239,18 +239,18 @@ class IfElseTransformer : Transformer() { } private fun Statement.isTailThrowOrReturn(): Boolean { - return if (isThrowStmt || isReturnStmt) { - true - } else if (isBlockStmt) { - val stmts = asBlockStmt().statements - if (stmts.isEmpty()) { - return false - } + return when (this) { + is ThrowStmt, is ReturnStmt -> true + is BlockStmt -> { + val stmts = statements + if (stmts.isEmpty()) { + return false + } - val tail = stmts[stmts.size - 1] - tail.isThrowStmt || tail.isReturnStmt - } else { - false + val tail = stmts[stmts.size - 1] + tail is ThrowStmt || tail is ReturnStmt + } + else -> false } } } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt index d255baf642..7a4139dd90 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt @@ -13,22 +13,21 @@ import javax.inject.Singleton class IncrementTransformer : Transformer() { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { unit.walk { stmt: ExpressionStmt -> - if (!stmt.expression.isUnaryExpr) { + val expr = stmt.expression + if (expr !is UnaryExpr) { return@walk } - val unaryExpr = stmt.expression.asUnaryExpr() - unaryExpr.operator = unaryExpr.operator.toPostfix() + expr.operator = expr.operator.toPostfix() } unit.walk { stmt: ForStmt -> for (expr in stmt.update) { - if (!expr.isUnaryExpr) { + if (expr !is UnaryExpr) { continue } - val unaryExpr = expr.asUnaryExpr() - unaryExpr.operator = unaryExpr.operator.toPostfix() + expr.operator = expr.operator.toPostfix() } } } diff --git a/deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt b/deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt index 7feef152ba..0ab02dec61 100644 --- a/deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt +++ b/deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt @@ -37,7 +37,7 @@ fun Long.toHexLiteralExpr(): LongLiteralExpr { } fun Expression.isIntegerOrLongLiteral(): Boolean { - return isIntegerLiteralExpr || isLongLiteralExpr + return this is IntegerLiteralExpr || this is LongLiteralExpr } fun Long.toLongLiteralExpr(): LongLiteralExpr { @@ -66,48 +66,45 @@ fun Expression.negate(): Expression { } fun Expression.not(): Expression { - if (isUnaryExpr) { - val unary = asUnaryExpr() - if (unary.operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { - return unary.expression.clone() + when (this) { + is UnaryExpr -> { + if (operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { + return expression.clone() + } } - } else if (isBinaryExpr) { - val binary = asBinaryExpr() - - val left = binary.left - val right = binary.right - - @Suppress("NON_EXHAUSTIVE_WHEN") - when (binary.operator) { - BinaryExpr.Operator.EQUALS -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.NOT_EQUALS) - BinaryExpr.Operator.NOT_EQUALS -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.EQUALS) - BinaryExpr.Operator.GREATER -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS_EQUALS) - BinaryExpr.Operator.GREATER_EQUALS -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS) - BinaryExpr.Operator.LESS -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER_EQUALS) - BinaryExpr.Operator.LESS_EQUALS -> - return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER) - BinaryExpr.Operator.AND -> - return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.OR) - BinaryExpr.Operator.OR -> - return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.AND) + is BinaryExpr -> { + @Suppress("NON_EXHAUSTIVE_WHEN") + when (operator) { + BinaryExpr.Operator.EQUALS -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.NOT_EQUALS) + BinaryExpr.Operator.NOT_EQUALS -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.EQUALS) + BinaryExpr.Operator.GREATER -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS_EQUALS) + BinaryExpr.Operator.GREATER_EQUALS -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS) + BinaryExpr.Operator.LESS -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER_EQUALS) + BinaryExpr.Operator.LESS_EQUALS -> + return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER) + BinaryExpr.Operator.AND -> + return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.OR) + BinaryExpr.Operator.OR -> + return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.AND) + } } - } else if (isBooleanLiteralExpr) { - return BooleanLiteralExpr(!asBooleanLiteralExpr().value) + is BooleanLiteralExpr -> return BooleanLiteralExpr(!value) } + return UnaryExpr(clone(), UnaryExpr.Operator.LOGICAL_COMPLEMENT) } fun Expression.countNots(): Int { var count = 0 - if (isUnaryExpr && asUnaryExpr().operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { + if (this is UnaryExpr && operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { count++ - } else if (isBinaryExpr && asBinaryExpr().operator == BinaryExpr.Operator.NOT_EQUALS) { + } else if (this is BinaryExpr && operator == BinaryExpr.Operator.NOT_EQUALS) { count++ }