ABSTRACT Traffic sign detection is a pivotal technology in the Intelligent Transportation System. Existing approaches suffer from low accuracy in complex scenes and high miss rate for small objects. To this end, this paper proposes a novel approach called ETSD to detect traffic signs based on enhanced features and attention. First, a heterogeneous feature enhancement block is designed to strengthen the network's capacity to capture fine‐grained features of small objects in both channel and spatial dimensions. Second, to resolve the challenges of local information degradation and global semantics ambiguity in deep networks, we introduce the selective guided attention to strengthen global semantics through 3D‐permutation modelling while preserving local details via neuron modelling. Finally, to further enhance the detection performance for small objects, we constructed a dedicated detection layer that extracts low‐level features of small objects and fuses them with deep network features. ETSD is rigorously evaluated on four benchmark datasets (CCTSDB2021, TT100K, GTSDB and RoadSign). It consistently surpasses YOLO11n, achieving a notable gain of 5.2% in mAP50 and 4.5% in mAP50:95 on CCTSDB2021. Moreover, its mAP50:95 is improved by 4.5%, 2.0% and 3.5% on TT100K, RoadSign and GTSDB, proving its effectiveness and robustness.

Conditional branching provides a fundamental structure for executing a specific branch based on the value of a boolean expression at run-time. However, repeated or nested conditional branching can lead to increased complexity. Furthermore, fall-through semantics in conditional branching result in uncontrollable jumps. Refactoring conditional branching manually is error-prone, time-consuming, and tedious. There is a critical need to provide automated refactoring support for conditional branching. To this end, this paper presentsReBrancher, an automated refactoring approach to eliminate repeated or nested conditional branching. Firstly,ReBrancherparses source code into an abstract syntax tree and walks through conditional branching statements. Secondly, it removes redundant fall-through semantics by static program analysis and an automaton. The automaton is constructed from a control flow graph to match patterns of conditional branching. Finally, it converts a conditional branching into aswitchexpression and removes the fall-through semantics.ReBrancherwas evaluated on nine real-world projects involving 25,137 conditional branchings. Experimental results show that a total of 1,790 conditional branching constructs are refactored within an average of 18.62 seconds per project. Furthermore,ReBrancherreduced the average cyclomatic complexity by 4.41% and removed 1,249 code smells, demonstrating its effectiveness in improving code quality.

Software refactoring is widely employed to improve software quality. However, conducting refactorings manually is tedious, time-consuming, and error-prone. Consequently, automated and semi-automated tool support is highly desirable for software refactoring in the industry, and most of the main-stream IDEs provide powerful tool support for refactoring. However, complex refactoring engines are prone to errors, which in turn may result in imperfect and incorrect refactorings. To this end, in this paper, we propose a ChatGPT-based approach to testing refactoring engines. We first manually analyze bug reports and test cases associated with refactoring engines, and construct a feature library containing fine-grained features that may trigger defects in refactoring engines. The approach automatically generates prompts according to both predefined prompt templates and features randomly selected from the feature library, requesting ChatGPT to generate test programs with the requested features. Test programs generated by ChatGPT are then forwarded to multiple refactoring engines for differential testing. To the best of our knowledge, it is the first approach in testing refactoring engines that guides test program generation with features derived from existing bugs. It is also the first approach in this line that exploits LLMs in the generation of test programs. Our initial evaluation of four main-stream refactoring engines suggests that the proposed approach is effective. It identified a total of 115 previously unknown bugs besides 28 inconsistent refactoring behaviors among different engines. Among the 115 bugs, 78 have been manually confirmed by the original developers of the tested engines, i.e., IntelliJ IDEA, Eclipse, VScode-Java, and NetBeans.

The try-with-resource statement is proposed as an exception-handling mechanism in JDK7, providing automated resource management and optimized exception handling. Existing IDEs do not provide sufficient support for the automatic refactoring of this exception-handling mechanism. Manual refactoring is both time-consuming and error-prone. To this end, this paper proposes an automatic refactoring approach called ExceRef to refactor exception-handling code automatically. ExceRef first obtains the refactoring target through the visitor pattern and then screens code that meets precondition checking. Subsequently, it tracks the status of resources by control flow analysis and judges the dependency between statements via dependency analysis, thereby inferring the code pattern for refactoring. Finally, it conducts refactoring by rewriting the AST of the source code. ExceRef is implemented as a plugin in the Eclipse JDT framework. We select five real-world projects to evaluate ExceRef from multiple aspects such as the number of refactorings, changed lines of code, refactoring time, and code maintainability after refactoring. The experimental results show that ExceRef refactors a total of 205 exception-handling statements with an average of 24.78s per project. ExceRef not only improves the maintainability of the code but also enhances the efficiency of refactoring.

Refactoring for locks is widely used to improve the scalability and performance of concurrent programs. However, when refactoring from coarse-grained locks to fine-grained locks, the behavior of concurrent programs may be changed. To this end, we present LockCheck, a consistency-checking approach based on the parallel extended finite automaton for fine-grained locks. First, we model the critical sections of concurrent programs through control flow analysis and dependency analysis. Second, we sequentialize the concurrent programs to get all the possible transition paths. Furthermore, it reduces the exploration of the redundant paths using partial order theory to obtain the compared transition paths. Finally, we combine consistency rules to check the consistency of the program before and after refactoring. We evaluated LockCheck in five open-source projects. A total of 1528 refactoring operations have been evaluated and 93 inconsistent refactoring operations have been detected. The results show that LockCheck can effectively detect inconsistent behavior when coarse-grained locks are refactored into fine-grained locks.

Abstract Code smell is the structural design defect that makes programs difficult to understand, maintain, and evolve. Existing works of code smell detection mainly focus on prevalent code smells, such as feature envy, god class, and long method. Few works have been done on detecting brain class/method. Furthermore, existing deep‐learning‐based approaches leverage the CNN model to improve accuracy by barely increasing the number of layers, which may cause a problem of gradient degradation. To this end, this paper proposes a novel approach called MARS to detect brain class/method. MARS improves the gradient degradation by employing an improved residual network. It increases the weight value of those important code metrics to label smelly samples by introducing a metric–attention mechanism. To support the training of MARS, a dataset called BrainCode is generated by extracting more than 270,000 samples from 20 real‐world applications. MARS is evaluated on BrainCode and compared to other machine‐learning‐based and deep‐learning‐based approaches. The experimental results demonstrate that the average accuracy of MARS is 2.01 % higher than that of the existing approaches, which improves state‐of‐the‐art.

Abstract The instanceof pattern matching can improve the code quality and readability by removing the redundant typecasting and simplifying the design in different scenarios. However, existing works do not provide sufficient support for refactoring instanceof pattern matching. This paper first identifies several cases that cannot be well handled by existing IDEs. Based on these observations, we propose a novel approach called ReInstancer to refactor instanceof pattern matching automatically. ReInstancer conducts program analysis for multi‐branch statements to obtain pattern variables. After analyzing these patterns, the multi‐branch statements are optimized and finally refactored into switch statements or expressions. ReInstancer is evaluated by 20 real‐world projects with more than 7,700 instanceof pattern matching. The experimental results demonstrate that a total of 3,558 instanceof expressions and 228 multi‐branch statements are refactored within 10.8 s on average for each project. ReInstancer improves the code quality by reducing redundant typecasting, demonstrating its effectiveness.