kotlin

This study addresses semantic discrepancies between parallel Java and Kotlin implementations in the Android framework, which can introduce security vulnerabilities. It presents ParaDroid, the first systematic analysis framework for detecting cross-language semantic differences at scale. ParaDroid integrates a bytecode-level intermediate representation, class-to-source mapping reconstruction, large language model–driven semantic reasoning, and comparative static and dynamic behavior analysis. Applied to 329 pairs of parallel methods in AOSP Android versions 14 through 16, the approach identified 37 instances of fragile semantic divergence, leading to the confirmation of three security vulnerabilities—two of which have been assigned CVE identifiers—and two functional defects.

Android app builds frequently fail due to complex dependency graphs, heterogeneous configuration schemes, and rapid ecosystem evolution. To address this, we conduct an empirical study analyzing build logs from 200 open-source Android projects and propose a five-stage diagnosis-and-repair framework. We systematically categorize build failures into four canonical patterns—the first such taxonomy in the literature. Innovatively, we integrate a large language model (GPT-5) to generate context-aware repair suggestions, which are then validated through automated build execution and manual verification. Our evaluation shows successful repair of 102 out of 135 initially failing projects (75.6% success rate). Furthermore, we identify programming language choice, project age, and application scale as statistically significant factors influencing build reliability. This work contributes both a reusable methodology and empirically grounded insights to enhance Android build robustness and maintainability.

This work addresses the challenge of detecting cross-language compilation bugs in multi-language JVM applications, which arise from semantic discrepancies between languages and are largely overlooked by existing compiler testing approaches focused on single-language settings. To bridge this gap, the authors propose the first differential testing framework tailored for cross-language JVM compilation. The approach leverages Kotlin’s unified intermediate representation (IR) to synthesize cross-language test programs and introduces seven custom mutation operators to enhance test diversity. This methodology enables the first systematic differential testing of multi-language JVM compilation scenarios, uncovering 32 confirmed bugs across five major compilers—Kotlin, Groovy, Scala 2/3, and Java. The findings demonstrate that the framework effectively exposes and mitigates semantic inconsistencies at language boundaries, significantly improving compiler reliability.

Kotlin’s multiplatform concurrency semantics exhibit inconsistencies across targets, and its memory model lacks formal verification. Method: This paper designs and implements the first Kotlin-specific cross-platform concurrency stress-testing framework. Built upon a custom domain-specific language (DSL) and compiler plugins, it enables unified execution of litmus tests on both Kotlin/JVM and Kotlin/Native—achieving “write once, run everywhere.” We propose a test-driven cross-platform verification architecture, deeply integrated into CI/CD pipelines. Contribution/Results: The framework uncovered and helped fix multiple compiler-level concurrency bugs in Kotlin, directly influencing the evolution of Kotlin’s official memory model. Open-sourced and adopted by the Kotlin official CI infrastructure, it has become the de facto standard tool for verifying semantic consistency of concurrent behavior across Kotlin multiplatform targets.

GUI test transfer across applications faces challenges such as mapping failure and incomplete test coverage due to structural heterogeneity among UI controls. This paper proposes a novel “abstraction–concretization” paradigm: instead of performing interface-level control mapping, it first abstracts universal test logic from multi-source, functionally equivalent test cases; then, leveraging a large language model (LLM), it concretizes this logic into executable test scripts for the target app via functional semantic alignment and joint GUI event–assertion generation. To our knowledge, this is the first approach to deeply integrate LLMs throughout both test logic generalization and target-specific adaptation, enabling functional-semantic-level transfer. Evaluated on the FrUITeR and Lin datasets, our method achieves functional test success rates of 64% (+191%) and 75% (+42%), respectively—demonstrating substantial improvements in transfer effectiveness and practicality.

This work addresses the challenges of language unfamiliarity and syntactic ambiguity in automatically migrating declarative UI code from Android (Jetpack Compose) and iOS (SwiftUI) to HarmonyOS ArkUI. To this end, the authors propose ArkTrans, a novel approach that synergistically combines heuristic skeleton guidance with empirical post-repair rules. Specifically, ArkTrans first constructs an ArkUI skeleton from metadata to steer large language models toward generating an initial translation, then applies pattern-matching-driven post-repair rules to correct syntactic errors. Evaluated on 100 real-world UI pages, ArkTrans achieves a compilable rate of 90.67% while preserving high visual fidelity, substantially outperforming existing strategies based on direct or single-shot prompting with large language models. This study represents the first demonstration of high-quality cross-platform migration for declarative UI frameworks.

This work addresses the challenges of IDE development posed by the rapid evolution of smart contract languages such as Move by presenting a high-performance IDE support system built atop the Move compiler and adhering to the Language Server Protocol (LSP). Through deep integration with existing language toolchains and the application of incremental parsing and optimized semantic analysis techniques, the system efficiently delivers rich IDE features even as the language undergoes continuous iteration. Deployed successfully within the Sui platform’s Move ecosystem, it significantly enhances developer experience and yields a reusable, evolution-aware IDE construction strategy applicable to other emerging programming language ecosystems.

This work addresses the performance overhead incurred by intermediate object creation in consecutive map() and filter() operations of the Java Stream API. The authors propose a compile-time optimization technique that transforms such operation chains into a single mapMulti() invocation via bytecode rewriting, thereby eliminating intermediate objects. This approach overcomes limitations of existing tools in handling lambda escape and stream variable assignments, and notably does not rely on loop unrolling. Experimental evaluation shows that the method significantly outperforms Streamliner on 2 out of 9 benchmarks while matching its performance on the rest. Furthermore, it successfully passes all 31,799 unit tests in Apache Kafka, demonstrating both correctness and practical applicability.

This work addresses the challenge of repairing visual defects in Android applications, which is often hindered by incomplete human-submitted bug reports lacking observed behavior (OB), expected behavior (EB), or steps to reproduce (S2Rs). To overcome this limitation, the authors propose the first approach that leverages GUI context to guide large language models (LLMs) in generating structured bug reports. By integrating interaction logs and screenshots, the method automatically produces comprehensive and accurate OB, EB, and S2Rs. A unified evaluation framework assessing both correctness and completeness is also introduced. Experimental results on 48 bug reports across 26 applications demonstrate that the generated reports significantly outperform both original human-written reports and existing LLM-based baselines in quality.