Project-specific code completion, which aims to complete code based on the context of the project, is an important and practical software engineering task. The state-of-the-art approaches employ the retrieval-augmented generation (RAG) paradigm and prompt large language models (LLMs) with information retrieved from the target project for project-specific code completion. In practice, developers always define and use custom functionalities, namely internal APIs, to facilitate the implementation of specific project requirements. Thus, it is essential to consider internal API information for accurate project-specific code completion. However, existing approaches either retrieve similar code snippets, which do not necessarily contain related internal API information, or retrieve internal API information based on import statements, which usually do not exist when the related internal APIs haven’t been used in the file. Therefore, these project-specific code completion approaches face challenges in effectiveness or practicability. To this end, this paper aims to enhance project-specific code completion by locating internal API information without relying on import statements. We first propose a method to infer internal API information. Our method first extends the representation of each internal API by constructing its usage examples and functional semantic information (i.e., a natural language description of the function’s purpose) and constructs a knowledge base. Based on the knowledge base, our method uses an initial completion solution generated by LLMs to infer the API information necessary for completion. Based on this method, we propose a code completion approach that enhances project-specific code completion by integrating similar code snippets and internal API information. Furthermore, we developed a benchmark named ProjBench, which consists of recent, large-scale real-world projects and is free of leaked import statements. We evaluated the effectiveness of our approach on ProjBench and an existing benchmark CrossCodeEval. Experimental results show that our approach outperforms the base-performing approach by an average of +5.91 in code exact match and +6.26 in identifier exact match, corresponding to relative improvements of 22.72% and 18.31%, respectively. We also show our method complements existing ones by integrating it into various baselines, boosting code match by +7.77 (47.80%) and identifier match by +8.50 (35.55%) on average.

Hypertension becomes a major public health problem due to its serious morbidity and mortality and serious cardiovascular, cerebrovascular and kidney complications. The complementary therapies of Traditional Chinese Medicine (TCM) play important roles in hypertension treatment. Acupuncture, as an important component in TCM, is frequently used in treatment hypertension. In this paper, we mined the data set of literature downloaded from SinoMed on hypertension focused on its treatment with acupuncture technology in TCM common use. The text mining results showed that Shuigou, Zhongshu, Burong, Zusanli, and Taichong were the top 5 acupoints, while Governor Meridian, Bladder Meridian of Foot-Taiyang and Stomach Meridian of Foot-Yangming were the top 3 meridian used for hypertension treatment. The combinations of acupoints were demonstrated in network, which were widely used in the clinical practices of acupuncture. The results provided good references for both clinical practice and medical research.

Hypertension becomes a major public health problem due to its high prevalence and serious complications. The complementary therapies of Traditional Chinese Medicine (TCM) play important roles in hypertension treatment. This study analyzed the application of the TCM external therapy and food therapy by text mining. Subsequently, suitable techniques and methods which were frequently used on hypertension treatment were explored. The text mining results showed that acupuncture, massage, Tuina, auricular-plaster and external application of Chinese herb medicine(CHM) were the top 5 TCM external therapy techniques, while placenta, lily root, pseudo-ginseng, peanut, sea horse, wine, radix aconiti carmichaeli, lemon, soybean and fructus crataegi were the top 10 foods used for hypertension treatment. The combinations of external therapy techniques were demonstrated in network, so does the combinations of the foods. The results provided good references for both clinical practice and medical research.

It is a still a world-wide challenge that hypertensive patients maintain a satisfactory blood pressure control. In TCM practice, traditional physical therapy has shown beneficial to blood pressure (BP) controlling. As the amount of bio medical data in leading databases (i.e. SinoMed, etc.) is growing at an exponential rate, it might be possible to get something meaningful through the techniques developed in data mining. In this paper, focused on hypertension, we proposed an algorithm named two dimensions data slicing to mine rules of Chinese medicinal physical therapies (massage, cupping and so on). The process of mining was done in two dimensions. The one-dimension analyzes the frequencies. The two-dimension analyzes the frequencies of co-existed keyword pairs. By examining the results of these two dimensions, although some noises existed, most regular knowledge of this disease is mined out. This algorithm might be useful in mining rules in the literature of traditional Chinese medicine.

Through several thousands years of clinical research and theoretical thoughts, traditional Chinese medicine (TCM) has accumulated rich experience on hypertension. However, the usage of Chinese herbal medicines (CHMs) in formulae is flexible in TCM clinical practice according to pattern differentiation. So, it is important to get the composition rules of Chinese herbal medicines through literatures. Based on the keyword list of Chinese herbal medicine, through the keyword filtering skill, we got the lists of Chinese herbal medicines. However, for Chinese herbal medicine, they are not only mentioned in the plain format of herb names, but also densely described in the form of formulae. As formulae are composed by Chinese herbal medicines according the theory of traditional Chinese medicine, so it is necessary to filtering them out and de-compose them back into specified Chinese herbal medicines. In this study, take hypertension for example, we explored the composition-rules of Chinese herbal medicines and the network of TCM pattern with them. Networks of TCM patterns and CHMs which are most frequently used in hypertension treatment are built-up and analyzed, some regularities are obtained in treating hypertension from 175011 records of literature. And this method could provide useful help for TCM clinical application and Chinese medicine research.

Software development teams exchange source code in shared repositories. These repositories are kept consistent by having developers follow a commit policy, such as ldquoProgram edits can be committed only if all available tests succeed.rdquo Such policies may result in long intervals between commits, increasing the likelihood of duplicative development and merge conflicts. Furthermore, commit policies are generally not automatically enforceable. We present a program analysis to identify committable changes that can be released early, without causing failures of existing tests, even in the presence of failing tests in a developer's local workspace. The algorithm can support relaxed commit policies that allow early release of changes, reducing the potential for merge conflicts. In experiments using several versions of a non-trivial software system with failing tests, 3 newly enabled commit policies were shown to allow a significant percentage of changes to be committed.

Crisp is an Eclipse plug-in tool for constructing intermediate versions of a Java program that is being edited. After a long editing session, a programmer will run regression tests to make sure she has not invalidated previously tested functionality. If a test fails unexpectedly, Crisp allows the programmer to select parts of the edit that affected the failing test and to add them to the original program, creating an intermediate version guaranteed to compile. Then the programmer can re-execute the test in order to locate the exact reasons for the failure by concentrating on those affecting changes that were applied. Using Crisp, a programmer can it- eratively select, apply, and undo individual (or sets of) affecting changes and, thus effectively find a small set of failure-inducing changes. Crisp is an extension to our change impact analysis tool, Chianti, [6].

In modern software development, regression tests are used to confirm the fundamental functionalities of an edited program and to assure the code quality. Difficulties occur when testing reveals unexpected behaviors, which indicate potential defects introduced by the edit. However, the changes that caused the failure(s) are not always easy to find. We propose a heuristic that ranks method changes that might have affected a failed test, indicating the likelihood that they may have contributed to a test failure. Our heuristic is based on the calling structure of the failed test (e.g., the number of ancestors and descendents of a method in the test's call graph, whether the caller or callee was changed, etc.). We evaluated the effectiveness of the heuristic in 14 pairs of edited versions in the Eclipse jdt core plug-in, using the test suite from its compiler tests plug-in. Our results indicate that when a failure is caused by a single method change, our heuristic ranked the failure-inducing change as number 1 or number 2 of all the method changes in 67% of the delegate tests (i.e., representatives of all failing tests). Even when the failure is caused by some combination of the changes, rather than a single change, our heuristic still helps.

Testing and code editing are interleaved activities during program development. When tests fail unexpectedly, the changes that caused the failure(s) are not always easy to find. We explore how change classification can focus programmer attention on failure-inducing changes by automatically labeling changes Red, Yellow, or Green, indicating the likelihood that they have contributed to a test failure. We implemented our change classification tool JUnit/CIA as an extension to the JUnit component within Eclipse, and evaluated its effectiveness in two case studies. Our results indicate that change classification is an effective technique for finding failure-inducing changes.

During program maintenance, a programmer may make changes that enhance program functionality or fix bugs in code. Then, the programmer usually will run unit/regression tests to prevent invalidation of previously tested functionality. If a test fails unexpectedly, the programmer needs to explore the edit to find the failure-inducing changes for that test. Crisp uses results from Chianti, a tool that performs semantic change impact analysis [1], to allow the programmer to examine those parts of the edit that affect the failing test. Crisp then builds a compilable intermediate version of the program by adding a programmer-selected partial edit to the original code, augmenting the selection as necessary to ensure compilation. The programmer can reexecute the test on the intermediate version in order to locate the exact reasons for the failure by concentrating on the specific changes that were applied. In nine initial case studies on pairs of versions from two real Java programs, Daikon [2] and Eclipse jdt compiler [3], we were able to use Crisp to identify the failure-inducing changes for all but 1 of 68 failing tests. On average, 33 changes were found to affect each failing test (of the 67), but only 1-4 of these changes were found to be actually failure-inducing.

Chianti is a change impact analysis tool for Java that is implemented in the context of the Eclipse environment. Chianti analyzes two versions of a Java program, decomposes their difference into a set of atomic changes, and a partial order inter-dependences of these changes is calculated. Change impact is then reported in terms of affected (regression or unit) tests whose execution behavior may have been modified by the applied changes. For each affected test, Chianti also determines a set of affecting changes that were responsible for the test's modified behavior. This latter step of isolating failure inducing changes for one specific test from irrelevant changes can be used as a debugging technique in situations where a test fails unexpectedly after a long editing session.

Crisp is a tool (i.e., an Eclipse plug-in) for constructing intermediate versions of a Java program that is being edited in an IDE such as Eclipse. After a long editing session, a programmer usually would run regression tests to make sure she has not invalidated previously checked functionality. If a test fails unexpectedly, Crisp uses input from Chianti, a tool for semantic change impact analysis, to allow the programmer to select parts of the edit that affected the failing test and to add them to the original program, creating an intermediate version guaranteed to compile. Then the programmer can re-execute the test in order to locate the exact reasons for the failure by concentrating on those affecting changes that were applied. Using Crisp, a programmer can iteratively select, apply, and undo individual (or sets of) affecting changes and, thus effectively find a small set of failure-inducing changes.

This paper reports on the design and implementation of Chianti, a change impact analysis tool for Java that is implemented in the context of the Eclipse environment. Chianti analyzes two versions of an application and decomposes their difference into a set of atomic changes. Change impact is then reported in terms of affected (regression or unit) tests whose execution behavior may have been modified by the applied changes. For each affected test, Chianti also determines a set of affecting changes that were responsible for the test's modified behavior. This latter step of isolating the changes that induce the failure of one specific test from those changes that only affect other tests can be used as a debugging technique in situations where a test fails unexpectedly after a long editing session. We evaluated Chianti on a year (2002) of CVS data from M. Ernst's Daikon system, and found that, on average, 52% of Daikon's unit tests are affected. Furthermore, each affected unit test, on average, is affected by only 3.95% of the atomic changes. These findings suggest that our change impact analysis is a promising technique for assisting developers with program understanding and debugging.