fix(naming): use JADX local-name aliases

Match JADX ApplyVariableNames for type fallbacks (i/str/obj/iArr) and
ProcessKotlinInternals for Intrinsics check strings. Keep high-score
semantic names when the solver already recovered them.

Author: LLeavesG

dexdec/src/analysis/jadx_local_names.rs

@@ -0,0 +1,246 @@
+//! Local names that follow JADX's `ApplyVariableNames` and
+//! `ProcessKotlinInternals` rules.
+//!
+//! JADX never falls back to a DEX register (`v12`). It names a local from a
+//! Kotlin `Intrinsics` check string when one exists, otherwise from the value's
+//! type or defining call.
+
+use std::collections::BTreeMap;
+
+use crate::ir::{
+    ArgType, InsnType, LiteralArg, MemberReference, PrimitiveType, SemanticExpression,
+    SemanticNode, SemanticOperation, SemanticVisitor,
+};
+
+const OBJECT_ALIASES: &[(&str, &str)] = &[
+    ("java.lang.String", "str"),
+    ("kotlin.String", "str"),
+    ("java.lang.Class", "cls"),
+    ("java.lang.Throwable", "th"),
+    ("java.lang.Object", "obj"),
+    ("kotlin.Any", "obj"),
+    ("java.util.Iterator", "it"),
+    ("kotlin.collections.Iterator", "it"),
+    ("java.util.HashMap", "map"),
+    ("java.lang.Boolean", "bool"),
+    ("java.lang.Short", "sh"),
+    ("java.lang.Integer", "num"),
+    ("java.lang.Character", "ch"),
+    ("java.lang.Byte", "b"),
+    ("java.lang.Float", "f"),
+    ("java.lang.Long", "l"),
+    ("java.lang.Double", "d"),
+    ("java.lang.StringBuilder", "sb"),
+    ("java.lang.Exception", "exc"),
+];
+
+const INVOKE_PREFIXES: &[&str] = &["get", "set", "to", "parse", "read", "format"];
+
+pub(crate) fn primitive_local_name(primitive: PrimitiveType) -> Option<&'static str> {
+    match primitive {
+        PrimitiveType::Boolean => Some("z"),
+        PrimitiveType::Byte => Some("b"),
+        PrimitiveType::Short => Some("s"),
+        PrimitiveType::Char => Some("c"),
+        PrimitiveType::Int => Some("i"),
+        PrimitiveType::Long => Some("j"),
+        PrimitiveType::Float => Some("f"),
+        PrimitiveType::Double => Some("d"),
+        PrimitiveType::Void | PrimitiveType::Object | PrimitiveType::Array => None,
+    }
+}
+
+pub(crate) fn object_alias(qualified: &str) -> Option<&'static str> {
+    OBJECT_ALIASES
+        .iter()
+        .find(|(name, _)| *name == qualified)
+        .map(|(_, alias)| *alias)
+}
+
+pub(crate) fn class_local_name(simple: &str) -> String {
+    if simple.is_empty() {
+        return "obj".to_string();
+    }
+    let alphabetic = simple
+        .chars()
+        .filter(|character| character.is_alphabetic())
+        .collect::<Vec<_>>();
+    if !alphabetic.is_empty() && alphabetic.iter().all(|character| character.is_uppercase()) {
+        return simple.to_lowercase();
+    }
+    let mut characters = simple.chars();
+    let Some(first) = characters.next() else {
+        return "obj".to_string();
+    };
+    let mut lowered = first.to_lowercase().collect::<String>();
+    lowered.extend(characters);
+    if lowered != simple {
+        return lowered;
+    }
+    format!("{simple}Var")
+}
+
+pub(crate) fn array_local_name(element: &str) -> String {
+    format!("{element}Arr")
+}
+
+pub(crate) fn class_local_name_from_segments<'a>(
+    segments: impl IntoIterator<Item = &'a str>,
+) -> String {
+    let segments = segments.into_iter().collect::<Vec<_>>();
+    let qualified = segments.join(".");
+    if let Some(alias) = object_alias(&qualified) {
+        return alias.to_string();
+    }
+    class_local_name(segments.last().copied().unwrap_or(""))
+}
+
+pub(crate) fn trim_intrinsic_name(name: &str) -> &str {
+    name.strip_prefix("$this$")
+        .or_else(|| name.strip_prefix('$'))
+        .unwrap_or(name)
+}
+
+pub(crate) fn invoke_local_name(method: &str) -> Option<String> {
+    if method == "iterator" {
+        return Some("it".to_string());
+    }
+    if method == "getInstance" {
+        return None;
+    }
+    for prefix in INVOKE_PREFIXES {
+        if let Some(rest) = method.strip_prefix(prefix) {
+            if rest
+                .chars()
+                .next()
+                .is_some_and(|character| character.is_ascii_uppercase())
+            {
+                return Some(class_local_name(rest));
+            }
+        }
+    }
+    None
+}
+
+pub(crate) fn intrinsic_local_names(root: &SemanticNode) -> BTreeMap<u32, String> {
+    let mut collector = IntrinsicNameCollector::default();
+    collector.visit_node(root);
+    collector.names
+}
+
+#[derive(Default)]
+struct IntrinsicNameCollector {
+    names: BTreeMap<u32, String>,
+}
+
+impl SemanticVisitor for IntrinsicNameCollector {
+    fn enter_operation(&mut self, operation: &SemanticOperation) {
+        if let Some((variable, name)) = intrinsic_binding(operation) {
+            self.names.entry(variable).or_insert(name);
+        }
+    }
+}
+
+fn intrinsic_binding(operation: &SemanticOperation) -> Option<(u32, String)> {
+    if operation.insn_type != InsnType::Invoke {
+        return None;
+    }
+    let MemberReference::Method(method) = operation.payload.reference.as_ref()? else {
+        return None;
+    };
+    if !is_kotlin_varname_source(method) {
+        return None;
+    }
+    let operands = operation.operands();
+    if operands.len() < 2 {
+        return None;
+    }
+    let variable = register_variable(&operands[0])?;
+    let name = const_string(operands.last()?)?;
+    let name = trim_intrinsic_name(&name);
+    if name.is_empty() {
+        return None;
+    }
+    Some((variable, name.to_string()))
+}
+
+fn is_kotlin_varname_source(method: &crate::ir::MethodReference) -> bool {
+    let parameters = &method.descriptor.parameters;
+    if method.descriptor.return_type != ArgType::VOID {
+        return false;
+    }
+    let string = ArgType::object("java/lang/String");
+    let object = ArgType::object("java/lang/Object");
+    let signature_ok = matches!(
+        parameters.as_slice(),
+        [left, right] if left == &object && right == &string
+    ) || matches!(
+        parameters.as_slice(),
+        [left, middle, right] if left == &object && middle == &string && right == &string
+    );
+    if !signature_ok {
+        return false;
+    }
+    let owner = method.owner.as_object().unwrap_or("");
+    owner == "kotlin/jvm/internal/Intrinsics"
+        || owner.ends_with("/Intrinsics")
+        || method.name.starts_with("checkNotNull")
+        || method.name.starts_with("checkParameterIsNotNull")
+        || method.name.starts_with("checkExpressionValueIsNotNull")
+}
+
+fn register_variable(expression: &SemanticExpression) -> Option<u32> {
+    match expression {
+        SemanticExpression::Register(register) => register.code_var,
+        _ => None,
+    }
+}
+
+fn const_string(expression: &SemanticExpression) -> Option<String> {
+    match expression {
+        SemanticExpression::Operation(operation) if operation.insn_type == InsnType::ConstStr => {
+            Some(operation.payload.string_value.as_ref()?.to_string_lossy())
+        }
+        SemanticExpression::Literal(LiteralArg { .. }) => None,
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn primitive_names_match_jadx_short_names() {
+        assert_eq!(primitive_local_name(PrimitiveType::Int), Some("i"));
+        assert_eq!(primitive_local_name(PrimitiveType::Boolean), Some("z"));
+        assert_eq!(primitive_local_name(PrimitiveType::Long), Some("j"));
+    }
+
+    #[test]
+    fn object_aliases_match_jadx() {
+        assert_eq!(object_alias("java.lang.String"), Some("str"));
+        assert_eq!(object_alias("java.lang.Object"), Some("obj"));
+        assert_eq!(object_alias("kotlin.Any"), Some("obj"));
+    }
+
+    #[test]
+    fn class_and_array_names_match_jadx() {
+        assert_eq!(class_local_name("FooBar"), "fooBar");
+        assert_eq!(class_local_name("HTML"), "html");
+        assert_eq!(class_local_name("v0"), "v0Var");
+        assert_eq!(array_local_name("i"), "iArr");
+        assert_eq!(
+            class_local_name_from_segments(["java", "lang", "String"]),
+            "str"
+        );
+    }
+
+    #[test]
+    fn intrinsic_and_invoke_names_match_jadx() {
+        assert_eq!(trim_intrinsic_name("$this$foo"), "foo");
+        assert_eq!(trim_intrinsic_name("$view"), "view");
+        assert_eq!(invoke_local_name("getView"), Some("view".to_string()));
+        assert_eq!(invoke_local_name("iterator"), Some("it".to_string()));
+    }
+}

dexdec/src/analysis/java_backend/semantic_naming.rs

@@ -1,13 +1,14 @@
 use std::collections::{BTreeMap, BTreeSet};
 
+use crate::analysis::jadx_local_names;
 use crate::ir::{
     analysis::{
         StructuralVariableRoleAnalysis, VariableNode, VariableRole, VariableRoleAnalysis,
         VariableRoleScores, VariableSemanticGraph,
     },
-    ArgType, InsnType, MemberReference, SemanticNode,
+    ArgType, InsnType, MemberReference, PrimitiveType, SemanticNode,
 };
-use crate::language::java::{JavaIdentifier, JavaType};
+use crate::language::java::{JavaIdentifier, JavaPrimitiveType, JavaType};
 
 use super::type_names::JavaTypeNameResolver;
 
@@ -106,15 +107,9 @@ impl MethodResultSemantics for JavaMethodResultSemantics {
             return None;
         }
         let identifier = JavaIdentifier::from_hint(name);
-        if let Some(noun) = name.strip_prefix("get").filter(|noun| {
-            noun.chars()
-                .next()
-                .is_some_and(|character| character.is_ascii_uppercase())
-        }) {
+        if let Some(name) = jadx_local_names::invoke_local_name(name) {
             return Some(NameCandidate {
-                name: self
-                    .morphology
-                    .lower_camel(&JavaIdentifier::from_hint(noun)),
+                name: JavaIdentifier::from_hint(&name),
                 score: 85,
             });
         }
@@ -188,23 +183,7 @@ impl<'a> StructuralNameModel<'a> {
     }
 
     fn java_type_name(&self, ty: &JavaType) -> Option<JavaIdentifier> {
-        match ty {
-            JavaType::Class(class) => {
-                let name = &class.segments.last()?.name;
-                let source = name.as_str();
-                (source != "Object" && !is_register_style_name(source))
-                    .then(|| self.morphology.lower_camel(name))
-            }
-            JavaType::Array(element) => self
-                .java_type_name(element)
-                .map(|name| self.morphology.plural(&name))
-                .or_else(|| Some(JavaIdentifier::from_hint("values"))),
-            JavaType::Variable(name) => Some(self.morphology.lower_camel(name)),
-            JavaType::Primitive(crate::language::java::JavaPrimitiveType::Boolean) => {
-                Some(JavaIdentifier::from_hint("flag"))
-            }
-            JavaType::Primitive(_) => None,
-        }
+        Some(JavaIdentifier::from_hint(&java_jadx_type_name(ty)?))
     }
 
     fn lower_camel(name: &JavaIdentifier) -> JavaIdentifier {
@@ -429,9 +408,7 @@ impl<'a> ParameterNameRecovery<'a> {
     }
 
     pub(super) fn candidate(&self, ty: &ArgType) -> Option<JavaIdentifier> {
-        ty.is_reference()
-            .then(|| self.model.type_name(ty))
-            .flatten()
+        self.model.type_name(ty)
     }
 }
 
@@ -552,16 +529,23 @@ impl<'a> SemanticNameRecovery<'a> {
     ) -> BTreeMap<u32, JavaIdentifier> {
         let graph = VariableSemanticGraph::analyze(root, source_types);
         let roles = StructuralVariableRoleAnalysis.analyze(&graph);
+        let intrinsic_names = jadx_local_names::intrinsic_local_names(root);
         let excluded = parameter_variables
             .iter()
             .copied()
             .flatten()
             .chain(this_variable)
+            .chain(intrinsic_names.keys().copied())
             .collect::<BTreeSet<_>>();
         let model = StructuralNameModel::for_graph(self.types, &graph);
         let mut names =
             ConstrainedNameSolver::new(StructuralNameModel::for_graph(self.types, &graph), 35)
                 .solve(&graph, &roles, parameter_names, &excluded);
+        for (identity, name) in intrinsic_names {
+            names
+                .entry(identity)
+                .or_insert_with(|| JavaIdentifier::from_hint(&name));
+        }
         fill_remaining_source_names(
             &graph,
             &roles,
@@ -574,10 +558,33 @@ impl<'a> SemanticNameRecovery<'a> {
     }
 }
 
-fn is_register_style_name(name: &str) -> bool {
-    name.strip_prefix('v').is_some_and(|digits| {
-        !digits.is_empty() && digits.bytes().all(|byte| byte.is_ascii_digit())
-    })
+fn java_jadx_type_name(ty: &JavaType) -> Option<String> {
+    match ty {
+        JavaType::Primitive(primitive) => {
+            jadx_local_names::primitive_local_name(java_primitive(*primitive)).map(str::to_string)
+        }
+        JavaType::Class(class) => Some(jadx_local_names::class_local_name_from_segments(
+            class.segments.iter().map(|segment| segment.name.as_str()),
+        )),
+        JavaType::Variable(name) => Some(jadx_local_names::class_local_name(name.as_str())),
+        JavaType::Array(element) => Some(jadx_local_names::array_local_name(&java_jadx_type_name(
+            element,
+        )?)),
+    }
+}
+
+fn java_primitive(primitive: JavaPrimitiveType) -> PrimitiveType {
+    match primitive {
+        JavaPrimitiveType::Void => PrimitiveType::Void,
+        JavaPrimitiveType::Boolean => PrimitiveType::Boolean,
+        JavaPrimitiveType::Byte => PrimitiveType::Byte,
+        JavaPrimitiveType::Short => PrimitiveType::Short,
+        JavaPrimitiveType::Char => PrimitiveType::Char,
+        JavaPrimitiveType::Int => PrimitiveType::Int,
+        JavaPrimitiveType::Long => PrimitiveType::Long,
+        JavaPrimitiveType::Float => PrimitiveType::Float,
+        JavaPrimitiveType::Double => PrimitiveType::Double,
+    }
 }
 
 fn fill_remaining_source_names(