Attachment #224198 for bug #378024

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 65-70 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ImportRewriteTest.java (-8 / +1395 lines)
65	}	65	}
66		66
67	public static Test suite() {	67	public static Test suite() {
		68	// System.err.println("Warning, only part of the ImportRewriteTest are being executed!");
		69	// Suite suite = new Suite(ImportRewriteTest.class.getName());
		70	// suite.addTest(new ImportRewriteTest("testRemoveImports1"));
		71	// return suite;
68	return allTests();	72	return allTests();
69	}	73	}
70		74
Lines 1913-1918 Link Here
1913	"import java.util.Map.*;\n" +	1917	"import java.util.Map.*;\n" +
1914	"\n" +	1918	"\n" +
1915	"/* lead 2/import java.io.PrintWriter.; // test2\n" +	1919	"/* lead 2/import java.io.PrintWriter.; // test2\n" +
		1920	"\n" +
1916	"/* lead 3*/ import java.util.Map.SomethingElse; // test3\n" +	1921	"/* lead 3*/ import java.util.Map.SomethingElse; // test3\n" +
1917	"// commen 3\n" +	1922	"// commen 3\n" +
1918	"\n" +	1923	"\n" +
Lines 1973-1978 Link Here
1973	"\n" +	1978	"\n" +
1974	"// comment 1\n" +	1979	"// comment 1\n" +
1975	"/* lead 2/import java.io.PrintWriter.; // test2\n" +	1980	"/* lead 2/import java.io.PrintWriter.; // test2\n" +
		1981	"\n" +
1976	"/* lead 1/ import java.util.; // test1\n" +	1982	"/* lead 1/ import java.util.; // test1\n" +
1977	"import java.util.Map.*;\n" +	1983	"import java.util.Map.*;\n" +
1978	"/* lead 3*/ import java.util.Map.SomethingElse; // test3\n" +	1984	"/* lead 3*/ import java.util.Map.SomethingElse; // test3\n" +
Lines 2032-2042 Link Here
2032	"package pack1;\n" +	2038	"package pack1;\n" +
2033	"\n" +	2039	"\n" +
2034	"// comment 1\n" +	2040	"// comment 1\n" +
2035	"/* lead 2*/" +	2041	"/* lead 2// lead 1/ import java.util.; // test1\n" +
2036	"import java.util.*;\n" +
2037	"// test2\n" +	2042	"// test2\n" +
2038	"/* lead 1*/ \n" +
2039	"// test1\n" +
2040	"/* lead 3*/ \n" +	2043	"/* lead 3*/ \n" +
2041	"// test3\n" +	2044	"// test3\n" +
2042	"// commen 3\n" +	2045	"// commen 3\n" +
Lines 2096-2103 Link Here
2096	"\n" +	2099	"\n" +
2097	"// comment 1\n" +	2100	"// comment 1\n" +
2098	"/* lead 1*/ " +	2101	"/* lead 1*/ " +
2099	"import java.util.Map.*;\n" +	2102	"import java.util.Map.*; // test1\n" +
2100	"// test1\n" +
2101	"/* lead 2*/\n" +	2103	"/* lead 2*/\n" +
2102	"// test2\n" +	2104	"// test2\n" +
2103	"/* lead 3*/ \n" +	2105	"/* lead 3*/ \n" +
Lines 2159-2168 Link Here
2159	"// comment 1\n" +	2161	"// comment 1\n" +
2160	"/* lead 2/import java.io.PrintWriter.; // test2\n" +	2162	"/* lead 2/import java.io.PrintWriter.; // test2\n" +
2161	"\n" +	2163	"\n" +
2162	"/* lead 1*/ \n" +	2164	"/* lead 1/ import java.util.;\n" +
2163	" // test1\n" +	2165	" // test1\n" +
2164	"// commen 3\n" +	2166	"// commen 3\n" +
2165	"import java.util.*;\n" +
2166	"\n" +	2167	"\n" +
2167	"public class C {\n" +	2168	"public class C {\n" +
2168	" public static void main(String[] args) {\n" +	2169	" public static void main(String[] args) {\n" +
Lines 2178-2183 Link Here
2178	assertEqualString(cu.getSource(), buf.toString());	2179	assertEqualString(cu.getSource(), buf.toString());
2179	}	2180	}
2180		2181
		2182	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=376930
		2183	// separating comment should not prevent folding into *-import
		2184	public void testBug376930_5e() throws Exception {
		2185	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
		2186	StringBuffer buf = new StringBuffer();
		2187	buf.append(
		2188	"package pack1;\n" +
		2189	"\n" +
		2190	"import java.util.Map;\n" +
		2191	"/* comment leading Map.Entry */\n" +
		2192	"import java.util.Map.Entry;\n" +
		2193	"\n" +
		2194	"public class C {\n" +
		2195	" public static void main(String[] args) {\n" +
		2196	" HashMap h;\n" +
		2197	"\n" +
		2198	" Map.Entry e= null;\n" +
		2199	" Entry e2= null;\n" +
		2200	"\n" +
		2201	" }\n" +
		2202	"}");
		2203	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
		2204
		2205	String[] order = new String[] { "java", "javax", "org", "com" };
		2206
		2207	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, true);
		2208	imports.setUseContextToFilterImplicitImports(true);
		2209	imports.addImport("java.util.HashMap");
		2210
		2211	apply(imports);
		2212
		2213	buf = new StringBuffer();
		2214	buf.append(
		2215	"package pack1;\n" +
		2216	"\n" +
		2217	"import java.util.*;\n" +
		2218	"/* comment leading Map.Entry */\n" +
		2219	"import java.util.Map.Entry;\n" +
		2220	"\n" +
		2221	"public class C {\n" +
		2222	" public static void main(String[] args) {\n" +
		2223	" HashMap h;\n" +
		2224	"\n" +
		2225	" Map.Entry e= null;\n" +
		2226	" Entry e2= null;\n" +
		2227	"\n" +
		2228	" }\n" +
		2229	"}");
		2230	assertEqualString(cu.getSource(), buf.toString());
		2231	}
		2232
		2233	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
		2234	public void testBug378024() throws Exception {
		2235	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
		2236	StringBuffer buf = new StringBuffer();
		2237	buf.append(
		2238	"package pack1;\n" +
		2239	"\n" +
		2240	"// comment 1\n" +
		2241	"/*\n" +
		2242	" * keep me with List\n" +
		2243	" *\n" +
		2244	" */\n" +
		2245	"import java.awt.List;// test1\n" +
2246	"/*\n" +
2247	" * keep me with Serializable\n" +
2248	" */\n" +
2249	"import java.io.Serializable;// test2\n" +
2250	"/*\n" +
2251	" * keep me with HashMap\n" +
2252	" */\n" +
2253	"import java.util.HashMap;// test3\n" +
2254	"// commen 3\n" +
2255	"\n" +
2256	"public class C implements Serializable{\n" +
2257	" public static void main(String[] args) {\n" +
2258	" List l = new List();\n" +
2259	" Map e= null;\n" +
2260	" }\n" +
2261	"}");
2262	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2263
2264	String[] order = new String[] { "java", "java.awt", "java.io", "java.util" };
2265
2266	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, false);
2267	imports.setUseContextToFilterImplicitImports(true);
2268	imports.addImport("java.awt.List");
2269	imports.addImport("java.io.Serializable");
2270	imports.addImport("java.util.HashMap");
2271
2272	apply(imports);
2273
2274	buf = new StringBuffer();
2275	buf.append(
2276	"package pack1;\n" +
2277	"\n" +
2278	"// comment 1\n" +
2279	"/*\n" +
2280	" * keep me with List\n" +
2281	" *\n" +
2282	" */\n" +
2283	"import java.awt.List;// test1\n\n" +
2284	"/*\n" +
2285	" * keep me with Serializable\n" +
2286	" */\n" +
2287	"import java.io.Serializable;// test2\n\n" +
2288	"/*\n" +
2289	" * keep me with HashMap\n" +
2290	" */\n" +
2291	"import java.util.HashMap;// test3\n" +
2292	"// commen 3\n" +
2293	"\n" +
2294	"public class C implements Serializable{\n" +
2295	" public static void main(String[] args) {\n" +
2296	" List l = new List();\n" +
2297	" Map e= null;\n" +
2298	" }\n" +
2299	"}");
2300	assertEqualString(cu.getSource(), buf.toString());
2301	}
2302
2303	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2304	public void testBug378024b() throws Exception {
2305	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2306	StringBuffer buf = new StringBuffer();
2307	buf.append(
2308	"package pack1;\n" +
2309	"\n" +
2310	"// comment 1\n" +
2311	"/*\n" +
2312	" * don't move me 1\n" +
2313	" *\n" +
2314	" */\n" +
2315	"import java.awt.List;// test1\n" +
2316	"/*\n" +
2317	" * don't move me 2\n" +
2318	" */\n" +
2319	"import java.io.Serializable;// test2\n" +
2320	"/*\n" +
2321	" * don't move me 3\n" +
2322	" */\n" +
2323	"import java.util.HashMap;// test3\n" +
2324	"// commen 3\n" +
2325	"\n" +
2326	"public class C implements Serializable{\n" +
2327	" public static void main(String[] args) {\n" +
2328	" List l = new List();\n" +
2329	" Map e= null;\n" +
2330	" }\n" +
2331	"}");
2332	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2333
2334	String[] order = new String[] { "java", "java.util", "com", "pack" };
2335
2336	ImportRewrite imports= newImportsRewrite(cu, order, 1, 1, false);
2337	imports.setUseContextToFilterImplicitImports(true);
2338	imports.addImport("java.awt.List");
2339	imports.addImport("java.io.Serializable");
2340	imports.addImport("java.util.HashMap");
2341
2342	apply(imports);
2343
2344	buf = new StringBuffer();
2345	buf.append(
2346	"package pack1;\n" +
2347	"\n" +
2348	"// comment 1\n" +
2349	"/*\n" +
2350	" * don't move me 1\n" +
2351	" *\n" +
2352	" */\n" +
2353	"import java.awt.*;// test1\n" +
2354	"/*\n" +
2355	" * don't move me 2\n" +
2356	" */\n" +
2357	"import java.io.*;// test2\n" +
2358	"\n" +
2359	"/*\n" +
2360	" * don't move me 3\n" +
2361	" */\n" +
2362	"import java.util.*;// test3\n" +
2363	"// commen 3\n" +
2364	"\n" +
2365	"public class C implements Serializable{\n" +
2366	" public static void main(String[] args) {\n" +
2367	" List l = new List();\n" +
2368	" Map e= null;\n" +
2369	" }\n" +
2370	"}");
2371	assertEqualString(cu.getSource(), buf.toString());
2372	}
2373
2374	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2375	// leading and trailing comments always move with imports.
2376	// comments in between stay where they are
2377	public void testBug378024c() throws Exception {
2378	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2379	StringBuffer buf = new StringBuffer();
2380	buf.append(
2381	"package pack1;\n" +
2382	"\n" +
2383	"// comment 1\n" +
2384	"/*\n" +
2385	" * don't move me 1\n" +
2386	" *\n" +
2387	" */\n" +
2388	"\n" +
2389	"// lead 1\n" +
2390	"import java.awt.List;// test1\n" +
2391	"\n" +
2392	"/*\n" +
2393	" * don't move me 2\n" +
2394	" */\n" +
2395	"\n" +
2396	"// lead 2\n" +
2397	"import java.io.Serializable;// test2\n" +
2398	"/*\n" +
2399	" * don't move me 3\n" +
2400	" */\n" +
2401	"\n" +
2402	"/*\n" +
2403	" * don't move me 4\n" +
2404	" */\n" +
2405	"\n" +
2406	"//lead 3\n" +
2407	"import java.util.HashMap;// test3\n" +
2408	"// commen 3\n" +
2409	"\n" +
2410	"public class C implements Serializable{\n" +
2411	" public static void main(String[] args) {\n" +
2412	" List l = new List();\n" +
2413	" Map e= null;\n" +
2414	" }\n" +
2415	"}");
2416	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2417
2418	String[] order = new String[] { "java", "java.util", "com", "pack" };
2419
2420	ImportRewrite imports= newImportsRewrite(cu, order, 99, 99, false);
2421	imports.setUseContextToFilterImplicitImports(true);
2422	imports.addImport("java.awt.List");
2423	imports.addImport("java.io.Serializable");
2424	imports.addImport("java.util.HashMap");
2425
2426	apply(imports);
2427
2428	buf = new StringBuffer();
2429	buf.append(
2430	"package pack1;\n" +
2431	"\n" +
2432	"// comment 1\n" +
2433	"/*\n" +
2434	" * don't move me 1\n" +
2435	" *\n" +
2436	" */\n" +
2437	"\n" +
2438	"// lead 1\n" +
2439	"import java.awt.List;// test1\n" +
2440	"\n" +
2441	"//lead 3\n" +
2442	"import java.util.HashMap;// test3\n" +
2443	"// commen 3\n" +
2444	"/*\n" +
2445	" * don't move me 2\n" +
2446	" */\n" +
2447	"// lead 2\n" +
2448	"import java.io.Serializable;// test2\n" +
2449	"/*\n" +
2450	" * don't move me 3\n" +
2451	" */\n" +
2452	"/*\n" +
2453	" * don't move me 4\n" +
2454	" */\n" +
2455	"public class C implements Serializable{\n" +
2456	" public static void main(String[] args) {\n" +
2457	" List l = new List();\n" +
2458	" Map e= null;\n" +
2459	" }\n" +
2460	"}");
2461	assertEqualString(cu.getSource(), buf.toString());
2462	}
2463
2464	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2465	// leading and trailing comments always move with imports.
2466	// comments in between stay where they are
2467	public void testBug378024c_1() throws Exception {
2468	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2469	StringBuffer buf = new StringBuffer();
2470	buf.append(
2471	"package pack1;\n" +
2472	"\n" +
2473	"// comment 1\n" +
2474	"/*\n" +
2475	" * don't move me 1\n" +
2476	" *\n" +
2477	" */\n" +
2478	"\n" +
2479	"// lead 1\n" +
2480	"import java.awt.List;// test1\n" +
2481	"\n" +
2482	"/*\n" +
2483	" * don't move me 2\n" +
2484	" */\n" +
2485	"\n" +
2486	"// lead 2\n" +
2487	"import java.io.Serializable;// test2\n" +
2488	"/*\n" +
2489	" * don't move me 3\n" +
2490	" */\n" +
2491	"\n" +
2492	"/*\n" +
2493	" * don't move me 4\n" +
2494	" */\n" +
2495	"\n" +
2496	"//lead 3\n" +
2497	"import java.util.HashMap;// test3\n" +
2498	"// commen 3\n" +
2499	"\n" +
2500	"public class C implements Serializable{\n" +
2501	" public static void main(String[] args) {\n" +
2502	" List l = new List();\n" +
2503	" Map e= null;\n" +
2504	" }\n" +
2505	"}");
2506	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2507
2508	String[] order = new String[] { "java", "com", "pack" };
2509
2510	ImportRewrite imports= newImportsRewrite(cu, order, 99, 99, false);
2511	imports.setUseContextToFilterImplicitImports(true);
2512	imports.addImport("java.awt.List");
2513	imports.addImport("java.io.Serializable");
2514	imports.addImport("java.util.HashMap");
2515
2516	apply(imports);
2517
2518	buf = new StringBuffer();
2519	buf.append(
2520	"package pack1;\n" +
2521	"\n" +
2522	"// comment 1\n" +
2523	"/*\n" +
2524	" * don't move me 1\n" +
2525	" *\n" +
2526	" */\n" +
2527	"\n" +
2528	"// lead 1\n" +
2529	"import java.awt.List;// test1\n" +
2530	"/*\n" +
2531	" * don't move me 2\n" +
2532	" */\n" +
2533	"// lead 2\n" +
2534	"import java.io.Serializable;// test2\n" +
2535	"/*\n" +
2536	" * don't move me 3\n" +
2537	" */\n" +
2538	"/*\n" +
2539	" * don't move me 4\n" +
2540	" */\n" +
2541	"//lead 3\n" +
2542	"import java.util.HashMap;// test3\n" +
2543	"// commen 3\n" +
2544	"\n" +
2545	"public class C implements Serializable{\n" +
2546	" public static void main(String[] args) {\n" +
2547	" List l = new List();\n" +
2548	" Map e= null;\n" +
2549	" }\n" +
2550	"}");
2551	assertEqualString(cu.getSource(), buf.toString());
2552	}
2553
2554	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2555	// leading and trailing comments always move with imports, even if they get folded.
2556	// comments in between stay where they are
2557	public void testBug378024c_2() throws Exception {
2558	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2559	StringBuffer buf = new StringBuffer();
2560	buf.append(
2561	"package pack1;\n" +
2562	"\n" +
2563	"// comment 1\n" +
2564	"/*\n" +
2565	" * don't move me 1\n" +
2566	" *\n" +
2567	" */\n" +
2568	"\n" +
2569	"// lead 1\n" +
2570	"import java.awt.List;// test1\n" +
2571	"\n" +
2572	"/*\n" +
2573	" * don't move me 2\n" +
2574	" */\n" +
2575	"\n" +
2576	"// lead 2\n" +
2577	"import java.io.Serializable;// test2\n" +
2578	"/*\n" +
2579	" * don't move me 3\n" +
2580	" */\n" +
2581	"\n" +
2582	"/*\n" +
2583	" * don't move me 4\n" +
2584	" */\n" +
2585	"\n" +
2586	"//lead 3\n" +
2587	"import java.util.HashMap;// test3\n" +
2588	"// commen 3\n" +
2589	"\n" +
2590	"public class C implements Serializable{\n" +
2591	" public static void main(String[] args) {\n" +
2592	" List l = new List();\n" +
2593	" Map e= null;\n" +
2594	" }\n" +
2595	"}");
2596	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2597
2598	String[] order = new String[] { "java", "com", "pack" };
2599
2600	ImportRewrite imports= newImportsRewrite(cu, order, 1, 1, false);
2601	imports.setUseContextToFilterImplicitImports(true);
2602	imports.addImport("java.awt.List");
2603	imports.addImport("java.io.Serializable");
2604	imports.addImport("java.util.HashMap");
2605
2606	apply(imports);
2607
2608	buf = new StringBuffer();
2609	buf.append(
2610	"package pack1;\n" +
2611	"\n" +
2612	"// comment 1\n" +
2613	"/*\n" +
2614	" * don't move me 1\n" +
2615	" *\n" +
2616	" */\n" +
2617	"\n" +
2618	"// lead 1\n" +
2619	"import java.awt.*;// test1\n" +
2620	"/*\n" +
2621	" * don't move me 2\n" +
2622	" */\n" +
2623	"// lead 2\n" +
2624	"import java.io.*;// test2\n" +
2625	"/*\n" +
2626	" * don't move me 3\n" +
2627	" */\n" +
2628	"/*\n" +
2629	" * don't move me 4\n" +
2630	" */\n" +
2631	"//lead 3\n" +
2632	"import java.util.*;// test3\n" +
2633	"// commen 3\n" +
2634	"\n" +
2635	"public class C implements Serializable{\n" +
2636	" public static void main(String[] args) {\n" +
2637	" List l = new List();\n" +
2638	" Map e= null;\n" +
2639	" }\n" +
2640	"}");
2641	assertEqualString(cu.getSource(), buf.toString());
2642	}
2643
2644	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2645	// not adding an import should preserve its comments and put them at the end.
2646	public void testBug378024d() throws Exception {
2647	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2648	StringBuffer buf = new StringBuffer();
2649	buf.append(
2650	"package pack1;\n" +
2651	"\n" +
2652	"// comment 1\n" +
2653	"/*\n" +
2654	" * don't move me 1\n" +
2655	" *\n" +
2656	" */\n" +
2657	"\n" +
2658	"// lead 1\n" +
2659	"import java.awt.List;// test1\n" +
2660	"\n" +
2661	"/*\n" +
2662	" * don't move me 2\n" +
2663	" */\n" +
2664	"\n" +
2665	"// lead 2\n" +
2666	"import java.io.Serializable;// test2\n" +
2667	"/*\n" +
2668	" * don't move me 3\n" +
2669	" */\n" +
2670	"\n" +
2671	"/*\n" +
2672	" * don't move me 4\n" +
2673	" */\n" +
2674	"\n" +
2675	"//lead 3\n" +
2676	"import java.util.HashMap;// test3\n" +
2677	"// commen 3\n" +
2678	"\n" +
2679	"public class C implements Serializable{\n" +
2680	" public static void main(String[] args) {\n" +
2681	" List l = new List();\n" +
2682	" Map e= null;\n" +
2683	" }\n" +
2684	"}");
2685	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2686
2687	String[] order = new String[] { "java", "java.util", "com", "pack" };
2688
2689	ImportRewrite imports= newImportsRewrite(cu, order, 1, 1, false);
2690	imports.setUseContextToFilterImplicitImports(true);
2691	imports.addImport("java.awt.List");
2692	imports.addImport("java.util.HashMap");
2693
2694	apply(imports);
2695
2696	buf = new StringBuffer();
2697	buf.append(
2698	"package pack1;\n" +
2699	"\n" +
2700	"// comment 1\n" +
2701	"/*\n" +
2702	" * don't move me 1\n" +
2703	" *\n" +
2704	" */\n" +
2705	"\n" +
2706	"// lead 1\n" +
2707	"import java.awt.*;// test1\n" +
2708	"\n" +
2709	"//lead 3\n" +
2710	"import java.util.*;// test3\n" +
2711	"// commen 3\n" +
2712	"/*\n" +
2713	" * don't move me 4\n" +
2714	" */" +
2715	"/*\n" +
2716	" * don't move me 2\n" +
2717	" */\n" +
2718	"// lead 2\n" +
2719	"// test2\n" +
2720	"/*\n" +
2721	" * don't move me 3\n" +
2722	" */\n" +
2723	"\n" +
2724	"public class C implements Serializable{\n" +
2725	" public static void main(String[] args) {\n" +
2726	" List l = new List();\n" +
2727	" Map e= null;\n" +
2728	" }\n" +
2729	"}");
2730	assertEqualString(cu.getSource(), buf.toString());
2731	}
2732
2733	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2734	// adding a new import should not disturb comments and import should be added in its group
2735	public void testBug378024e() throws Exception {
2736	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2737	StringBuffer buf = new StringBuffer();
2738	buf.append(
2739	"package pack1;\n" +
2740	"\n" +
2741	"// comment 1\n" +
2742	"/*\n" +
2743	" * don't move me 1\n" +
2744	" *\n" +
2745	" */\n" +
2746	"\n" +
2747	"// lead 1\n" +
2748	"import java.awt.List;// test1\n" +
2749	"\n" +
2750	"/*\n" +
2751	" * don't move me 2\n" +
2752	" */\n" +
2753	"\n" +
2754	"// lead 2\n" +
2755	"import java.io.Serializable;// test2\n" +
2756	"/*\n" +
2757	" * don't move me 3\n" +
2758	" */\n" +
2759	"\n" +
2760	"/*\n" +
2761	" * don't move me 4\n" +
2762	" */\n" +
2763	"\n" +
2764	"//lead 3\n" +
2765	"import java.util.HashMap;// test3\n" +
2766	"// commen 3\n" +
2767	"\n" +
2768	"public class C implements Serializable{\n" +
2769	" public static void main(String[] args) {\n" +
2770	" List l = new List();\n" +
2771	" Map e= null;\n" +
2772	" }\n" +
2773	"}");
2774	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2775
2776	String[] order = new String[] { "java", "com", "pack" };
2777
2778	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, false);
2779	imports.setUseContextToFilterImplicitImports(true);
2780	imports.addImport("java.awt.List");
2781	imports.addImport("java.io.Serializable");
2782	imports.addImport("java.io.PrintWriter");
2783	imports.addImport("java.util.HashMap");
2784
2785	apply(imports);
2786
2787	buf = new StringBuffer();
2788	buf.append(
2789	"package pack1;\n" +
2790	"\n" +
2791	"// comment 1\n" +
2792	"/*\n" +
2793	" * don't move me 1\n" +
2794	" *\n" +
2795	" */\n" +
2796	"\n" +
2797	"// lead 1\n" +
2798	"import java.awt.List;// test1\n" +
2799	"/*\n" +
2800	" * don't move me 2\n" +
2801	" */\n" +
2802	"// lead 2\n" +
2803	"import java.io.*;\n" +
2804	"// test2\n" +
2805	"/*\n" +
2806	" * don't move me 3\n" +
2807	" */\n" +
2808	"/*\n" +
2809	" * don't move me 4\n" +
2810	" */\n" +
2811	"//lead 3\n" +
2812	"import java.util.HashMap;// test3\n" +
2813	"// commen 3\n" +
2814	"\n" +
2815	"public class C implements Serializable{\n" +
2816	" public static void main(String[] args) {\n" +
2817	" List l = new List();\n" +
2818	" Map e= null;\n" +
2819	" }\n" +
2820	"}");
2821	assertEqualString(cu.getSource(), buf.toString());
2822	}
2823
2824	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2825	// removing an import should preserve its comments at the end, and adding a new import should not disturb
2826	// existing comments
2827	public void testBug378024e_1() throws Exception {
2828	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2829	StringBuffer buf = new StringBuffer();
2830	buf.append(
2831	"package pack1;\n" +
2832	"\n" +
2833	"// comment 1\n" +
2834	"/*\n" +
2835	" * don't move me 1\n" +
2836	" *\n" +
2837	" */\n" +
2838	"\n" +
2839	"// lead 1\n" +
2840	"import java.awt.List;// test1\n" +
2841	"\n" +
2842	"/*\n" +
2843	" * don't move me 2\n" +
2844	" */\n" +
2845	"\n" +
2846	"// lead 2\n" +
2847	"import java.io.Serializable;// test2\n" +
2848	"/*\n" +
2849	" * don't move me 3\n" +
2850	" */\n" +
2851	"\n" +
2852	"/*\n" +
2853	" * don't move me 4\n" +
2854	" */\n" +
2855	"\n" +
2856	"//lead 3\n" +
2857	"import java.util.HashMap;// test3\n" +
2858	"// commen 3\n" +
2859	"\n" +
2860	"public class C implements Serializable{\n" +
2861	" public static void main(String[] args) {\n" +
2862	" List l = new List();\n" +
2863	" Map e= null;\n" +
2864	" }\n" +
2865	"}");
2866	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2867
2868	String[] order = new String[] { "java", "java.util", "com", "pack" };
2869
2870	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, false);
2871	imports.setUseContextToFilterImplicitImports(true);
2872	imports.addImport("java.awt.List");
2873	imports.addImport("java.io.PrintWriter");
2874	imports.addImport("java.util.HashMap");
2875
2876	apply(imports);
2877
2878	buf = new StringBuffer();
2879	buf.append(
2880	"package pack1;\n" +
2881	"\n" +
2882	"// comment 1\n" +
2883	"/*\n" +
2884	" * don't move me 1\n" +
2885	" *\n" +
2886	" */\n" +
2887	"\n" +
2888	"// lead 1\n" +
2889	"import java.awt.List;// test1\n" +
2890	"import java.io.PrintWriter;\n" +
2891	"\n" +
2892	"//lead 3\n" +
2893	"import java.util.HashMap;// test3\n" +
2894	"// commen 3\n" +
2895	"/*\n" +
2896	" * don't move me 4\n" +
2897	" */" +
2898	"/*\n" +
2899	" * don't move me 2\n" +
2900	" */\n" +
2901	"// lead 2\n" +
2902	"// test2\n" +
2903	"/*\n" +
2904	" * don't move me 3\n" +
2905	" */\n" +
2906	"\n" +
2907	"public class C implements Serializable{\n" +
2908	" public static void main(String[] args) {\n" +
2909	" List l = new List();\n" +
2910	" Map e= null;\n" +
2911	" }\n" +
2912	"}");
2913	assertEqualString(cu.getSource(), buf.toString());
2914	}
2915
2916	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
2917	// folding imports because of a newly added import should preserve comments
2918	public void testBug378024f() throws Exception {
2919	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
2920	StringBuffer buf = new StringBuffer();
2921	buf.append(
2922	"package pack1;\n" +
2923	"\n" +
2924	"// comment 1\n" +
2925	"/*\n" +
2926	" * don't move me 1\n" +
2927	" *\n" +
2928	" */\n" +
2929	"\n" +
2930	"// lead 1\n" +
2931	"import java.awt.List;// test1\n" +
2932	"\n" +
2933	"/*\n" +
2934	" * don't move me 2\n" +
2935	" */\n" +
2936	"\n" +
2937	"// lead 2\n" +
2938	"import java.io.Serializable;// test2\n" +
2939	"/*\n" +
2940	" * don't move me 3\n" +
2941	" */\n" +
2942	"\n" +
2943	"/*\n" +
2944	" * don't move me 4\n" +
2945	" */\n" +
2946	"\n" +
2947	"//lead 3\n" +
2948	"import java.util.HashMap;// test3\n" +
2949	"// commen 3\n" +
2950	"\n" +
2951	"public class C implements Serializable{\n" +
2952	" public static void main(String[] args) {\n" +
2953	" List l = new List();\n" +
2954	" Map e= null;\n" +
2955	" }\n" +
2956	"}");
2957	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
2958
2959	String[] order = new String[] { "java", "com", "pack" };
2960
2961	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, false);
2962	imports.setUseContextToFilterImplicitImports(true);
2963	imports.addImport("java.awt.List");
2964	imports.addImport("java.io.Serializable");
2965	imports.addImport("java.io.PrintWriter");
2966	imports.addImport("java.util.HashMap");
2967
2968	apply(imports);
2969
2970	buf = new StringBuffer();
2971	buf.append(
2972	"package pack1;\n" +
2973	"\n" +
2974	"// comment 1\n" +
2975	"/*\n" +
2976	" * don't move me 1\n" +
2977	" *\n" +
2978	" */\n" +
2979	"\n" +
2980	"// lead 1\n" +
2981	"import java.awt.List;// test1\n" +
2982	"/*\n" +
2983	" * don't move me 2\n" +
2984	" */\n" +
2985	"// lead 2\n" +
2986	"import java.io.*;\n" +
2987	"// test2\n" +
2988	"/*\n" +
2989	" * don't move me 3\n" +
2990	" */\n" +
2991	"/*\n" +
2992	" * don't move me 4\n" +
2993	" */\n" +
2994	"//lead 3\n" +
2995	"import java.util.HashMap;// test3\n" +
2996	"// commen 3\n" +
2997	"\n" +
2998	"public class C implements Serializable{\n" +
2999	" public static void main(String[] args) {\n" +
3000	" List l = new List();\n" +
3001	" Map e= null;\n" +
3002	" }\n" +
3003	"}");
3004	assertEqualString(cu.getSource(), buf.toString());
3005	}
3006
3007	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3008	// folding imports because of a newly added import should preserve comments
3009	public void testBug378024f_1() throws Exception {
3010	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3011	StringBuffer buf = new StringBuffer();
3012	buf.append(
3013	"package pack1;\n" +
3014	"\n" +
3015	"// comment 1\n" +
3016	"/*\n" +
3017	" * keep me with List\n" +
3018	" *\n" +
3019	" */\n" +
3020	"\n" +
3021	"// lead 1\n" +
3022	"import java.awt.List;// test1\n" +
3023	"\n" +
3024	"/*\n" +
3025	" * keep me with Serializable\n" +
3026	" */\n" +
3027	"\n" +
3028	"// lead 2\n" +
3029	"import java.io.Serializable;// test2\n" +
3030	"/*\n" +
3031	" * keep me with Serializable 2\n" +
3032	" */\n" +
3033	"\n" +
3034	"// lead 3\n" +
3035	"import java.io.PrintWriter;// test3\n" +
3036	"/*\n" +
3037	" * keep me with PrintWriter\n" +
3038	" */\n" +
3039	"\n" +
3040	"/*\n" +
3041	" * don't move me\n" +
3042	" */\n" +
3043	"\n" +
3044	"//lead 4\n" +
3045	"import java.util.HashMap;// test4\n" +
3046	"// commen 3\n" +
3047	"\n" +
3048	"public class C implements Serializable{\n" +
3049	" public static void main(String[] args) {\n" +
3050	" List l = new List();\n" +
3051	" Map e= null;\n" +
3052	" }\n" +
3053	"}");
3054	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3055
3056	String[] order = new String[] { "java", "java.util", "com", "pack" };
3057
3058	ImportRewrite imports= newImportsRewrite(cu, order, 2, 2, false);
3059	imports.setUseContextToFilterImplicitImports(true);
3060	imports.addImport("java.awt.List");
3061	imports.addImport("java.io.Serializable");
3062	imports.addImport("java.io.PrintWriter");
3063	imports.addImport("java.util.HashMap");
3064
3065	apply(imports);
3066
3067	buf = new StringBuffer();
3068	buf.append(
3069	"package pack1;\n" +
3070	"\n" +
3071	"// comment 1\n" +
3072	"/*\n" +
3073	" * keep me with List\n" +
3074	" *\n" +
3075	" */\n" +
3076	"\n" +
3077	"// lead 1\n" +
3078	"import java.awt.List;// test1\n" +
3079	"\n" +
3080	"//lead 4\n" +
3081	"import java.util.HashMap;// test4\n" +
3082	"// commen 3\n" +
3083	"/*\n" +
3084	" * keep me with Serializable\n" +
3085	" */\n" +
3086	"// lead 2\n" +
3087	"// lead 3\n" +
3088	"import java.io.*;// test3\n" +
3089	"/*\n" +
3090	" * keep me with PrintWriter\n" +
3091	" */\n" +
3092	"// test2\n" +
3093	"/*\n" +
3094	" * keep me with Serializable 2\n" +
3095	" */\n" +
3096	"/*\n" +
3097	" * don't move me\n" +
3098	" */\n" +
3099	"public class C implements Serializable{\n" +
3100	" public static void main(String[] args) {\n" +
3101	" List l = new List();\n" +
3102	" Map e= null;\n" +
3103	" }\n" +
3104	"}");
3105	assertEqualString(cu.getSource(), buf.toString());
3106	}
3107
3108	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3109	// Re-ordering imports and converting them to *
3110	public void testBug378024g() throws Exception {
3111	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3112	StringBuffer buf = new StringBuffer();
3113	buf.append(
3114	"package pack1;\n" +
3115	"\n" +
3116	"// comment 1\n" +
3117	"/*\n" +
3118	" * don't move me 1\n" +
3119	" *\n" +
3120	" */\n" +
3121	"\n" +
3122	"// lead 1\n" +
3123	"import java.awt.List;// test1\n" +
3124	"\n" +
3125	"/*\n" +
3126	" * don't move me 2\n" +
3127	" */\n" +
3128	"\n" +
3129	"// lead 2\n" +
3130	"import java.io.Serializable;// test2\n" +
3131	"/*\n" +
3132	" * don't move me 3\n" +
3133	" */\n" +
3134	"/*\n" +
3135	" * don't move me 4\n" +
3136	" */\n" +
3137	"\n" +
3138	"//lead 3\n" +
3139	"import java.util.HashMap;// test3\n" +
3140	"// commen 3\n" +
3141	"\n" +
3142	"public class C implements Serializable{\n" +
3143	" public static void main(String[] args) {\n" +
3144	" List l = new List();\n" +
3145	" Map e= null;\n" +
3146	" }\n" +
3147	"}");
3148	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3149
3150	String[] order = new String[] { "java", "java.awt", "java.util", "java.io", "com", "pack" };
3151
3152	ImportRewrite imports= newImportsRewrite(cu, order, 1, 1, false);
3153	imports.setUseContextToFilterImplicitImports(true);
3154	imports.addImport("java.awt.List");
3155	imports.addImport("java.io.Serializable");
3156	imports.addImport("java.util.HashMap");
3157
3158	apply(imports);
3159
3160	StringBuffer buf2 = new StringBuffer();
3161	buf2.append(
3162	"package pack1;\n" +
3163	"\n" +
3164	"// comment 1\n" +
3165	"/*\n" +
3166	" * don't move me 1\n" +
3167	" *\n" +
3168	" */\n" +
3169	"\n" +
3170	"// lead 1\n" +
3171	"import java.awt.*;// test1\n" +
3172	"\n" +
3173	"//lead 3\n" +
3174	"import java.util.*;// test3\n" +
3175	"// commen 3\n" +
3176	"\n" +
3177	"// lead 2\n" +
3178	"import java.io.*;// test2\n" +
3179	"/*\n" +
3180	" * don't move me 3\n" +
3181	" */\n" +
3182	"/*\n" +
3183	" * don't move me 4\n" +
3184	" */\n" +
3185	"/*\n" +
3186	" * don't move me 2\n" +
3187	" */\n" +
3188	"public class C implements Serializable{\n" +
3189	" public static void main(String[] args) {\n" +
3190	" List l = new List();\n" +
3191	" Map e= null;\n" +
3192	" }\n" +
3193	"}");
3194	assertEqualString(cu.getSource(), buf2.toString());
3195	}
3196
3197	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3198	// Preserve comments when imports are removed in case the restoring of imports is enabled
3199	// This will test changes in org.eclipse.jdt.internal.core.dom.rewrite.ImportRewriteAnalyzer.removeImport(String, boolean)
3200	public void testBug378024h() throws Exception {
3201	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3202	StringBuffer buf = new StringBuffer();
3203	buf.append(
3204	"package pack1;\n" +
3205	"\n" +
3206	"// comment 1\n" +
3207	"/*\n" +
3208	" * don't move me 1\n" +
3209	" *\n" +
3210	" */\n" +
3211	"\n" +
3212	"// lead 1\n" +
3213	"import java.awt.List;// test1\n" +
3214	"\n" +
3215	"/*\n" +
3216	" * don't move me 2\n" +
3217	" */\n" +
3218	"\n" +
3219	"// lead 2\n" +
3220	"import java.io.Serializable;// test2\n" +
3221	"/*\n" +
3222	" * don't move me 3\n" +
3223	" */\n" +
3224	"\n" +
3225	"/*\n" +
3226	" * don't move me 4\n" +
3227	" */\n" +
3228	"\n" +
3229	"//lead 3\n" +
3230	"import java.util.HashMap;// test3\n" +
3231	"// commen 3\n" +
3232	"\n" +
3233	"public class C implements Serializable{\n" +
3234	" public static void main(String[] args) {\n" +
3235	" Map e= null;\n" +
3236	" }\n" +
3237	"}");
3238	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3239
3240	String[] order = new String[] { "java", "java.util", "com", "pack" };
3241
3242	ImportRewrite imports= newImportsRewrite(cu, order, 99, 99, true);
3243	imports.setUseContextToFilterImplicitImports(true);
3244	imports.removeImport("java.awt.List");
3245
3246	apply(imports);
3247
3248	buf = new StringBuffer();
3249	buf.append(
3250	"package pack1;\n" +
3251	"\n" +
3252	"// comment 1\n" +
3253	"/*\n" +
3254	" * don't move me 1\n" +
3255	" *\n" +
3256	" */\n" +
3257	"\n" +
3258	"// lead 1\n" +
3259	"\n" +
3260	"/*\n" +
3261	" * don't move me 2\n" +
3262	" */\n" +
3263	"\n" +
3264	"// lead 2\n" +
3265	"import java.io.Serializable;// test2\n" +
3266	"/*\n" +
3267	" * don't move me 3\n" +
3268	" */\n" +
3269	"\n" +
3270	"/*\n" +
3271	" * don't move me 4\n" +
3272	" */\n" +
3273	"\n" +
3274	"\n" +
3275	"//lead 3\n" +
3276	"import java.util.HashMap;// test3\n" +
3277	"// commen 3\n" +
3278	"\n" +
3279	"public class C implements Serializable{\n" +
3280	" public static void main(String[] args) {\n" +
3281	" Map e= null;\n" +
3282	" }\n" +
3283	"}");
3284	assertEqualString(cu.getSource(), buf.toString());
3285	}
3286
3287	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3288	// Preserve comments when imports are removed in case the restoring of imports is enabled
3289	public void testBug378024h_1() throws Exception {
3290	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3291	StringBuffer buf = new StringBuffer();
3292	buf.append(
3293	"package pack1;\n" +
3294	"\n" +
3295	"// comment 1\n" +
3296	"/*\n" +
3297	" * don't move me 1\n" +
3298	" *\n" +
3299	" */\n" +
3300	"// lead 1\n" +
3301	"import java.awt.List;// test1\n" +
3302	"/* i am with List */\n" +
3303	"\n" +
3304	"/*\n" +
3305	" * don't move me 2\n" +
3306	" */\n" +
3307	"\n" +
3308	"// lead 2\n" +
3309	"import java.io.Serializable;// test2\n" +
3310	"/*\n" +
3311	" * don't move me 3\n" +
3312	" */\n" +
3313	"\n" +
3314	"/*\n" +
3315	" * don't move me 4\n" +
3316	" */\n" +
3317	"\n" +
3318	"//lead 3\n" +
3319	"import java.util.HashMap;// test3\n" +
3320	"// commen 3\n" +
3321	"\n" +
3322	"public class C implements Serializable{\n" +
3323	" public static void main(String[] args) {\n" +
3324	" Map e= null;\n" +
3325	" }\n" +
3326	"}");
3327	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3328
3329	String[] order = new String[] { "java", "java.util", "com", "pack" };
3330
3331	ImportRewrite imports= newImportsRewrite(cu, order, 99, 99, true);
3332	imports.setUseContextToFilterImplicitImports(true);
3333	imports.removeImport("java.awt.List");
3334	imports.addImport("java.util.List");
3335
3336	apply(imports);
3337
3338	buf = new StringBuffer();
3339	buf.append(
3340	"package pack1;\n" +
3341	"\n" +
3342	"// comment 1\n" +
3343	"/*\n" +
3344	" * don't move me 1\n" +
3345	" *\n" +
3346	" */\n" +
3347	"// lead 1\n" +
3348	"/* i am with List */\n" +
3349	"\n" +
3350	"/*\n" +
3351	" * don't move me 2\n" +
3352	" */\n" +
3353	"\n" +
3354	"// lead 2\n" +
3355	"import java.io.Serializable;// test2\n" +
3356	"/*\n" +
3357	" * don't move me 3\n" +
3358	" */\n" +
3359	"\n" +
3360	"/*\n" +
3361	" * don't move me 4\n" +
3362	" */\n" +
3363	"\n" +
3364	"\n" +
3365	"//lead 3\n" +
3366	"import java.util.HashMap;// test3\n" +
3367	"// commen 3\n" +
3368	"import java.util.List;\n" +
3369	"\n" +
3370	"public class C implements Serializable{\n" +
3371	" public static void main(String[] args) {\n" +
3372	" Map e= null;\n" +
3373	" }\n" +
3374	"}");
3375	assertEqualString(cu.getSource(), buf.toString());
3376	}
3377
3378	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3379	// Preserve comments when imports are unfolded.
3380	public void testBug378024i() throws Exception {
3381	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3382	StringBuffer buf = new StringBuffer();
3383	buf.append(
3384	"package pack1;\n" +
3385	"\n" +
3386	"// comment 1\n" +
3387	"/*\n" +
3388	" * don't move me 1\n" +
3389	" *\n" +
3390	" */\n" +
3391	"// lead 1\n" +
3392	"import java.awt.*;// test1\n" +
3393	"/* i am with List */\n" +
3394	"\n" +
3395	"/*\n" +
3396	" * don't move me 2\n" +
3397	" */\n" +
3398	"\n" +
3399	"// lead 2\n" +
3400	"import java.io.*;// test2\n" +
3401	"/*\n" +
3402	" * don't move me 3\n" +
3403	" */\n" +
3404	"\n" +
3405	"/*\n" +
3406	" * don't move me 4\n" +
3407	" */\n" +
3408	"\n" +
3409	"//lead 3\n" +
3410	"import java.util.*;// test3\n" +
3411	"// commen 3\n" +
3412	"\n" +
3413	"public class C implements Serializable{\n" +
3414	" public static void main(String[] args) {\n" +
3415	" HashMap e= null;\n" +
3416	" PrintWriter p= null;\n" +
3417	" List l= null;\n" +
3418	" }\n" +
3419	"}");
3420	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3421
3422	String[] order = new String[] { "java", "com", "pack" };
3423
3424	ImportRewrite imports= newImportsRewrite(cu, order, 99, 99, false);
3425	imports.setUseContextToFilterImplicitImports(true);
3426	imports.addImport("java.awt.List");
3427	imports.addImport("java.io.PrintWriter");
3428	imports.addImport("java.io.Serializable");
3429	imports.addImport("java.util.HashMap");
3430	imports.addImport("java.util.Map");
3431	apply(imports);
3432
3433	buf = new StringBuffer();
3434	buf.append(
3435	"package pack1;\n" +
3436	"\n" +
3437	"// comment 1\n" +
3438	"/*\n" +
3439	" * don't move me 1\n" +
3440	" *\n" +
3441	" */\n" +
3442	"// lead 1\n" +
3443	"import java.awt.List;// test1\n" +
3444	"/* i am with List */\n" +
3445	"/*\n" +
3446	" * don't move me 2\n" +
3447	" */\n" +
3448	"// lead 2\n" +
3449	"import java.io.PrintWriter;// test2\n" +
3450	"/*\n" +
3451	" * don't move me 3\n" +
3452	" */\n" +
3453	"import java.io.Serializable;\n" +
3454	"/*\n" +
3455	" * don't move me 4\n" +
3456	" */\n" +
3457	"//lead 3\n" +
3458	"import java.util.HashMap;// test3\n" +
3459	"// commen 3\n" +
3460	"import java.util.Map;\n" +
3461	"\n" +
3462	"public class C implements Serializable{\n" +
3463	" public static void main(String[] args) {\n" +
3464	" HashMap e= null;\n" +
3465	" PrintWriter p= null;\n" +
3466	" List l= null;\n" +
3467	" }\n" +
3468	"}");
3469	assertEqualString(cu.getSource(), buf.toString());
3470	}
3471
3472	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=378024
3473	// Preserve comments when imports are folded but a member type import is present
3474	public void testBug378024j() throws Exception {
3475	IPackageFragment pack1 = this.sourceFolder.createPackageFragment("pack1", false, null);
3476	StringBuffer buf = new StringBuffer();
3477	buf.append(
3478	"package pack1;\n" +
3479	"\n" +
3480	"// comment 1\n" +
3481	"/*\n" +
3482	" * don't move me 1\n" +
3483	" *\n" +
3484	" */\n" +
3485	"// lead 1\n" +
3486	"import java.awt.List;// test1\n" +
3487	"/* i am with List */\n" +
3488	"\n" +
3489	"/*\n" +
3490	" * don't move me 2\n" +
3491	" */\n" +
3492	"\n" +
3493	"//lead 3\n" +
3494	"import java.util.HashMap;// test3\n" +
3495	"/*\n" +
3496	" * don't move me 3\n" +
3497	" */\n" +
3498	"\n" +
3499	"/keep me with Map.Entry/\n" +
3500	"import java.util.Map.Entry;// member type import\n" +
3501	"/keep me with Map.Entry 2/\n" +
3502	"\n" +
3503	"/*\n" +
3504	" * don't move me 4\n" +
3505	" */\n" +
3506	"\n" +
3507	"// lead 2\n" +
3508	"import java.io.Serializable;// test2\n" +
3509	"// commen 3\n" +
3510	"\n" +
3511	"public class C implements Serializable{\n" +
3512	" public static void main(String[] args) {\n" +
3513	" Map e= null;\n" +
3514	" }\n" +
3515	"}");
3516	ICompilationUnit cu = pack1.createCompilationUnit("C.java", buf.toString(), false, null);
3517
3518	String[] order = new String[] { "java", "java.util", "com", "pack" };
3519
3520	ImportRewrite imports= newImportsRewrite(cu, order, 1, 1, false);
3521	imports.setUseContextToFilterImplicitImports(true);
3522	imports.addImport("java.awt.List");
3523	imports.addImport("java.util.HashMap");
3524	imports.addImport("java.util.Map.Entry");
3525	imports.addImport("java.io.Serializable");
3526
3527	apply(imports);
3528
3529	buf = new StringBuffer();
3530	buf.append(
3531	"package pack1;\n" +
3532	"\n" +
3533	"// comment 1\n" +
3534	"/*\n" +
3535	" * don't move me 1\n" +
3536	" *\n" +
3537	" */\n" +
3538	"// lead 1\n" +
3539	"import java.awt.*;// test1\n" +
3540	"/* i am with List */\n" +
3541	"\n" +
3542	"//lead 3\n" +
3543	"import java.util.*;// test3\n" +
3544	"/*\n" +
3545	" * don't move me 3\n" +
3546	" */\n" +
3547	"/keep me with Map.Entry/\n" +
3548	"import java.util.Map.Entry;// member type import\n" +
3549	"/keep me with Map.Entry 2/\n" +
3550	"/*\n" +
3551	" * don't move me 2\n" +
3552	" */" +
3553	"/*\n" +
3554	" * don't move me 4\n" +
3555	" */\n" +
3556	"// lead 2\n" +
3557	"import java.io.*;// test2\n" +
3558	"// commen 3\n" +
3559	"\n" +
3560	"public class C implements Serializable{\n" +
3561	" public static void main(String[] args) {\n" +
3562	" Map e= null;\n" +
3563	" }\n" +
3564	"}");
3565	assertEqualString(cu.getSource(), buf.toString());
3566	}
3567
2181	private void assertAddedAndRemoved(ImportRewrite imports, String[] expectedAdded, String[] expectedRemoved, String[] expectedAddedStatic, String[] expectedRemovedStatic) {	3568	private void assertAddedAndRemoved(ImportRewrite imports, String[] expectedAdded, String[] expectedRemoved, String[] expectedAddedStatic, String[] expectedRemovedStatic) {
2182	assertEqualStringsIgnoreOrder(imports.getAddedImports(), expectedAdded);	3569	assertEqualStringsIgnoreOrder(imports.getAddedImports(), expectedAdded);
2183	assertEqualStringsIgnoreOrder(imports.getAddedStaticImports(), expectedAddedStatic);	3570	assertEqualStringsIgnoreOrder(imports.getAddedStaticImports(), expectedAddedStatic);

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1051-1057 Link Here
1051	if (this.addedImports != null) {	1051	if (this.addedImports != null) {
1052	for (int i= 0; i < this.addedImports.size(); i++) {	1052	for (int i= 0; i < this.addedImports.size(); i++) {
1053	String curr= (String) this.addedImports.get(i);	1053	String curr= (String) this.addedImports.get(i);
1054	computer.addImport(curr.substring(1), STATIC_PREFIX == curr.charAt(0));	1054	computer.addImport(curr.substring(1), STATIC_PREFIX == curr.charAt(0), usedAstRoot, this.restoreExistingImports);
1055	}	1055	}
1056	}	1056	}
1057		1057




			int nextOffsetLine= root.getLineNumber(nextOffset);

			int extendedStart = root.getExtendedStartPosition(curr);
			int extendedLength = root.getExtendedLength(curr);
			if (extendedStart < this.replaceRange.getOffset()) {
				// don't touch the first comments before the start of import declarations
				extendedLength -=  (currOffset - extendedStart);
				extendedStart = currOffset;
			}
			
			// if next import is on a different line, modify the end position to the next line begin offset
			int nextLineOffset = nextOffset; // offset at the start of next line. Next import may not start here
			if (currEndLine < nextOffsetLine) {

			if (currEndLine < nextOffsetLine) {
				nextOffset= root.getPosition(nextOffsetLine, 0);

				int length = nextOffset - nextLineOffset;
				if (length > 2) { // valid comment has at least two chars
					currPackage.add(new ImportDeclEntry(packName.length(), null, false, new Region(nextLineOffset, length)));
				}

				currOffset= nextOffset;
			}

		}
		String groupId= null;
		int longestPrefix= -1;
		PackageEntry matchingCommentEntry = null;
		// find the matching group
		for (int i= 0; i < this.packageEntries.size(); i++) {
			PackageEntry curr= (PackageEntry) this.packageEntries.get(i);

				String currGroup= curr.getGroupID();
				if (currGroup != null && newName.startsWith(currGroup)) {
					int prefixLen= currGroup.length();
					if (prefixLen == newName.length() && !curr.isComment()) {
						return curr; // perfect fit, use entry
					} else if (curr.isComment()) {
						matchingCommentEntry = curr; // may be the only fit if no actual import of this group is already present
						continue;
					}
					if ((newName.charAt(prefixLen) == '.' || prefixLen == 0) && prefixLen > longestPrefix) {
						longestPrefix= prefixLen;

					}
				}
			}
		}
		if (matchingCommentEntry != null) {
			return matchingCommentEntry;
		}
		PackageEntry bestMatch= null;
		PackageMatcher matcher= new PackageMatcher();

		return qualifier.equals(packageName +'.' + mainTypeName);
	}

	public void addImport(String fullTypeName, boolean isStatic, CompilationUnit root, boolean restoreExistingImports) {
		String typeContainerName= getQualifier(fullTypeName, isStatic);
		ImportDeclEntry decl;
		if (restoreExistingImports) {
			decl = new ImportDeclEntry(typeContainerName.length(), fullTypeName, isStatic, null);
		} else {
			decl = addImportDeclEntry(typeContainerName, fullTypeName, isStatic, root);
		}
		sortIn(typeContainerName, decl, isStatic);
	}

	/**
	 * adds the import entry, but if its an existing import entry then preserves the comments surrounding the import
	 */
	private ImportDeclEntry addImportDeclEntry(String containerName, String fullTypeName, boolean isStatic, CompilationUnit root) {
		List/*ImportDeclaration*/ decls= root.imports();
		if (decls.isEmpty() || this.preserveExistingCommentsRanges == null || this.preserveExistingCommentsRanges.length == 0) {
			return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null);
		}
		IRegion precedingCommentRange = null;
		IRegion trailingCommentRange = null;
		int prevOffset = this.replaceRange.getOffset();  // will store offset of the previous import's extended end
		int numOfImports = decls.size();
		for (int i= 0; i < numOfImports; i++) {
			ImportDeclaration curr= (ImportDeclaration) decls.get(i);
			int currOffset= curr.getStartPosition();
			int currLength= curr.getLength();
			int currExtendedStart = root.getExtendedStartPosition(curr);
			int currExtendedLen = root.getExtendedLength(curr);
			String name= getFullName(curr);
			String packName= getQualifier(curr);
			if (packName.equals(containerName) && (name.equals(fullTypeName) || name.endsWith("*"))) {//$NON-NLS-1$
				int preserveCommentsLen = this.preserveExistingCommentsRanges.length;
				for (int j = 0; j < preserveCommentsLen; j++) {
					int offset = this.preserveExistingCommentsRanges[j].getOffset();
					boolean wasRangeUsed = false;
					int existingCommentLength = this.preserveExistingCommentsRanges[j].getLength();
					if (offset == currExtendedStart) {
						// comments belonging to this import's extended start
						precedingCommentRange = new Region(offset, existingCommentLength);
						wasRangeUsed = true;
					} else if (offset < currExtendedStart && offset > prevOffset) {
						// comment between two imports but not inside either's extended ranges
						// to preserve the position of these comments add a dummy comment entry
						PackageEntry commentEntry = new PackageEntry(); // create a comment package entry for this
						commentEntry.setGroupID(packName);	// the comment should belong to the current group
						this.packageEntries.add(commentEntry);
						commentEntry.add(new ImportDeclEntry(packName.length(), null, false, new Region(offset, existingCommentLength)));
						wasRangeUsed = true;
					} else if ((currExtendedStart + currExtendedLen) != (currOffset + currLength)){
						if (offset == currOffset + currLength) {
							// comment is in the extended end of the import
							trailingCommentRange = new Region(offset, existingCommentLength);
							wasRangeUsed = true;
						} else if (offset > (currOffset + currLength)) {
							break;
						}
					}
					if (wasRangeUsed) {
						// remove this comment from preserveExistingCommentsRanges array
						IRegion[] tempRegions = new IRegion[--preserveCommentsLen];
						System.arraycopy(this.preserveExistingCommentsRanges, 0, tempRegions, 0, j);
						System.arraycopy(this.preserveExistingCommentsRanges, j+1, tempRegions, j, tempRegions.length - j);
						this.preserveExistingCommentsRanges = tempRegions;
						j--;
					}
				}
				return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null, precedingCommentRange, trailingCommentRange);
			}
			prevOffset = currExtendedStart + currExtendedLen - 1;
		}
		return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null);
	}

	public boolean removeImport(String qualifiedName, boolean isStatic) {

					continue;
				}

				if (spacesBetweenGroups > 0 && lastPackage != null) {
					// add a space between two different groups by looking at the two adjacent imports
					if (!lastPackage.isComment() && !pack.isComment() && !pack.isSameGroup(lastPackage)) {
						for (int k= spacesBetweenGroups; k > 0; k--) {
							stringsToInsert.add(lineDelim);
						if (!lastPackage.isComment() && (last.isNew() || first.isNew())) {
							for (int k= spacesBetweenGroups; k > 0; k--) {
								stringsToInsert.add(lineDelim);
							}
						}
					} else if (lastPackage.isComment() && pack.isSameGroup(lastPackage)) {
						// the last pack may be a dummy for a comment which doesn't belong to any extended range
						stringsToInsert.add(lineDelim);
					}
				}
				lastPackage= pack;

				int threshold= isStatic ? this.staticImportOnDemandThreshold : this.importOnDemandThreshold;

				boolean doStarImport= pack.hasStarImport(threshold, onDemandConflicts);
				boolean allImportsAddedToStar = false;
				if (doStarImport && (pack.find("*") == null)) { //$NON-NLS-1$
					String[] imports = getNewImportStrings(buffer, pack, isStatic, lineDelim);
					for (int j = 0, max = imports.length; j < max; j++) {
						stringsToInsert.add(imports[j]);
					}
					allImportsAddedToStar = true; // may still need to handle onDemandConflicts below
				}

				for (int k= 0; k < nImports; k++) {
					ImportDeclEntry currDecl= pack.getImportAt(k);
					IRegion region= currDecl.getSourceRange();
					boolean isConflict = !currDecl.isComment() && onDemandConflicts != null && onDemandConflicts.contains(currDecl.getSimpleName());
					boolean addRegularToStar = doStarImport && !currDecl.isOnDemand();
					
					if (region == null) { // new entry
						if (!addRegularToStar || isConflict) {
							IRegion rangeBefore = currDecl.getPrecedingCommentRange();
							IRegion rangeAfter = currDecl.getTrailingCommentRange();
							if (rangeBefore != null) {
								stringsToInsert.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
							}
							
							String trailingComment = null;
							if (rangeAfter != null) {
								trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
							}
							String str= getNewImportString(currDecl.getElementName(), isStatic, trailingComment, lineDelim);
							stringsToInsert.add(str);
						} else if (addRegularToStar && !allImportsAddedToStar) {
							String simpleName = currDecl.getTypeQualifiedName();
							if (simpleName.indexOf('.') != -1) {
								String str= getNewImportString(currDecl.getElementName(), isStatic, lineDelim);

								}
							}
						}
					} else if (!addRegularToStar || isConflict) {
						int offset= region.getOffset();
						IRegion rangeBefore = currDecl.getPrecedingCommentRange();
						if (rangeBefore != null && currPos > rangeBefore.getOffset()) {

						removeAndInsertNew(buffer, currPos, offset, stringsToInsert, resEdit);
						stringsToInsert.clear();
						currPos= offset + region.getLength();
					} else if (addRegularToStar && !allImportsAddedToStar && !currDecl.isComment()) {
						String simpleName = currDecl.getTypeQualifiedName();
						if (simpleName.indexOf('.') != -1) {
							IRegion rangeBefore = currDecl.getPrecedingCommentRange();


			// insert back all existing imports comments since existing imports were not preserved
			if (this.preserveExistingCommentsRanges != null) {
				for (int i = 0, max = this.preserveExistingCommentsRanges.length; (i < max && this.preserveExistingCommentsRanges[i] != null); i++) {
					IRegion region = this.preserveExistingCommentsRanges[i];
					String text = buffer.getText(region.getOffset(), region.getLength());
					// remove preceding whitespaces

		List allImports = new ArrayList();
		int nImports = packageEntry.getNumberOfImports();
		StringBuffer allComments = null;
		StringBuffer allCommentsLead = null;
		for (int i= 0; i < nImports; i++) {
			ImportDeclEntry curr= packageEntry.getImportAt(i);
			if (curr.isComment()) {
			if (simpleName.indexOf('.') != -1) {
				// member type imports - we preserve it
				IRegion rangeBefore = curr.getPrecedingCommentRange();
				if (rangeBefore != null) {
					allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));

				if (rangeAfter != null) {
					trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
				}
				if (trailingComment != null) {
					allImports.add(buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength()));
				String starImportString= packageEntry.getName() + ".*"; //$NON-NLS-1$
				allImports.add(getNewImportString(starImportString, isStatic, lineDelim));
				isStarImportAdded = true;
			} else {
				// collect all comments
				IRegion rangeBefore = curr.getPrecedingCommentRange();
				if (rangeBefore != null) {
					if (allComments == null) {
						allComments = new StringBuffer();
					}
					allComments.append(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength())).append(lineDelim);
				}
			} else {
				String simpleName = curr.getTypeQualifiedName();
				if (simpleName.indexOf('.') != -1) {
					// member type imports - we preserve it
					IRegion rangeBefore = curr.getPrecedingCommentRange();
					if (rangeBefore != null) {
						allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
					}
					IRegion rangeAfter = curr.getTrailingCommentRange();
					String trailingComment = null;
					if (rangeAfter != null) {
						trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
					}
					allImports.add(getNewImportString(curr.getElementName(), isStatic, trailingComment, lineDelim));
				} else if (!isStarImportAdded) {
					String starImportString= packageEntry.getName() + ".*"; //$NON-NLS-1$
					// collect all comments
					IRegion rangeBefore = curr.getPrecedingCommentRange();
					if (rangeBefore != null) {
						allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
					}
					IRegion rangeAfter = curr.getTrailingCommentRange();
					String trailComments = null;
					if (rangeAfter != null) {
						trailComments = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
					}
					allImports.add(getNewImportString(starImportString, isStatic, trailComments, lineDelim));
					isStarImportAdded = true;
				} else {
					// collect all comments
					IRegion rangeBefore = curr.getPrecedingCommentRange();
					if (rangeBefore != null) {
						if (allCommentsLead == null) {
							allCommentsLead = new StringBuffer();
						}
						allCommentsLead.append(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
					}
					IRegion rangeAfter = curr.getTrailingCommentRange();
					if (rangeAfter != null) {
						if (allComments == null) {
							allComments = new StringBuffer();
						}
						allComments.append(buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength()));
					}
				}
			}
		}
		if (allCommentsLead != null) {
			allImports.add(0, String.valueOf(allCommentsLead));
		}
		if (allComments != null) {
			allImports.add(String.valueOf(allComments.append(lineDelim)));
		}
		return (String[]) allImports.toArray(new String[allImports.size()]);
	}

		private IRegion sourceRange;
		private final boolean isStatic;
		private int containerNameLength;
		IRegion precedingCommentRange;
		IRegion trailingCommentRange;

		public ImportDeclEntry(
				int containerNameLength,

				for (int i= 0; i < nImports; i++) {
					ImportDeclEntry curr= getImportAt(i);
					buf.append(" "); //$NON-NLS-1$
					if (curr.isComment()) {
						buf.append("comment"); //$NON-NLS-1$
					} else {
						if (curr.isStatic()) {
							buf.append("static "); //$NON-NLS-1$
						}
						buf.append(curr.getTypeQualifiedName());
					}
					buf.append(curr.getTypeQualifiedName());
					if (curr.isNew()) {
						buf.append(" (new)"); //$NON-NLS-1$
					}

Return to bug 378024

Lines 272-282 Link Here

(-)a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ImportRewriteAnalyzer.java (-49 / +173 lines)
272	int nextOffsetLine= root.getLineNumber(nextOffset);	272	int nextOffsetLine= root.getLineNumber(nextOffset);
273		273
274	int extendedStart = root.getExtendedStartPosition(curr);	274	int extendedStart = root.getExtendedStartPosition(curr);
		275	int extendedLength = root.getExtendedLength(curr);
275	if (extendedStart < this.replaceRange.getOffset()) {	276	if (extendedStart < this.replaceRange.getOffset()) {
276	// don't touch the first comments before the start of import declarations	277	// don't touch the first comments before the start of import declarations
		278	extendedLength -= (currOffset - extendedStart);
277	extendedStart = currOffset;	279	extendedStart = currOffset;
278	}	280	}
279	int extendedLength = root.getExtendedLength(curr);	281
280	// if next import is on a different line, modify the end position to the next line begin offset	282	// if next import is on a different line, modify the end position to the next line begin offset
281	int nextLineOffset = nextOffset; // offset at the start of next line. Next import may not start here	283	int nextLineOffset = nextOffset; // offset at the start of next line. Next import may not start here
282	if (currEndLine < nextOffsetLine) {	284	if (currEndLine < nextOffsetLine) {
Lines 313-321 Link Here
313	if (currEndLine < nextOffsetLine) {	315	if (currEndLine < nextOffsetLine) {
314	nextOffset= root.getPosition(nextOffsetLine, 0);	316	nextOffset= root.getPosition(nextOffsetLine, 0);
315		317
316	currPackage= new PackageEntry(); // create a comment package entry for this	318	int length = nextOffset - nextLineOffset;
317	this.packageEntries.add(currPackage);	319	if (length > 2) { // valid comment has at least two chars
318	currPackage.add(new ImportDeclEntry(packName.length(), null, false, new Region(nextLineOffset, nextOffset - nextLineOffset)));	320	currPackage.add(new ImportDeclEntry(packName.length(), null, false, new Region(nextLineOffset, length)));
		321	}
319		322
320	currOffset= nextOffset;	323	currOffset= nextOffset;
321	}	324	}
Lines 566-571 Link Here
566	}	569	}
567	String groupId= null;	570	String groupId= null;
568	int longestPrefix= -1;	571	int longestPrefix= -1;
		572	PackageEntry matchingCommentEntry = null;
569	// find the matching group	573	// find the matching group
570	for (int i= 0; i < this.packageEntries.size(); i++) {	574	for (int i= 0; i < this.packageEntries.size(); i++) {
571	PackageEntry curr= (PackageEntry) this.packageEntries.get(i);	575	PackageEntry curr= (PackageEntry) this.packageEntries.get(i);
Lines 573-580 Link Here
573	String currGroup= curr.getGroupID();	577	String currGroup= curr.getGroupID();
574	if (currGroup != null && newName.startsWith(currGroup)) {	578	if (currGroup != null && newName.startsWith(currGroup)) {
575	int prefixLen= currGroup.length();	579	int prefixLen= currGroup.length();
576	if (prefixLen == newName.length()) {	580	if (prefixLen == newName.length() && !curr.isComment()) {
577	return curr; // perfect fit, use entry	581	return curr; // perfect fit, use entry
		582	} else if (curr.isComment()) {
		583	matchingCommentEntry = curr; // may be the only fit if no actual import of this group is already present
		584	continue;
578	}	585	}
579	if ((newName.charAt(prefixLen) == '.' \|\| prefixLen == 0) && prefixLen > longestPrefix) {	586	if ((newName.charAt(prefixLen) == '.' \|\| prefixLen == 0) && prefixLen > longestPrefix) {
580	longestPrefix= prefixLen;	587	longestPrefix= prefixLen;
Lines 582-587 Link Here
582	}	589	}
583	}	590	}
584	}	591	}
		592	}
		593	if (matchingCommentEntry != null) {
		594	return matchingCommentEntry;
585	}	595	}
586	PackageEntry bestMatch= null;	596	PackageEntry bestMatch= null;
587	PackageMatcher matcher= new PackageMatcher();	597	PackageMatcher matcher= new PackageMatcher();
Lines 616-625 Link Here
616	return qualifier.equals(packageName +'.' + mainTypeName);	626	return qualifier.equals(packageName +'.' + mainTypeName);
617	}	627	}
618		628
619	public void addImport(String fullTypeName, boolean isStatic) {	629	public void addImport(String fullTypeName, boolean isStatic, CompilationUnit root, boolean restoreExistingImports) {
620	String typeContainerName= getQualifier(fullTypeName, isStatic);	630	String typeContainerName= getQualifier(fullTypeName, isStatic);
621	ImportDeclEntry decl= new ImportDeclEntry(typeContainerName.length(), fullTypeName, isStatic, null);	631	ImportDeclEntry decl;
		632	if (restoreExistingImports) {
		633	decl = new ImportDeclEntry(typeContainerName.length(), fullTypeName, isStatic, null);
		634	} else {
		635	decl = addImportDeclEntry(typeContainerName, fullTypeName, isStatic, root);
		636	}
622	sortIn(typeContainerName, decl, isStatic);	637	sortIn(typeContainerName, decl, isStatic);
		638	}
		639
		640	/**
		641	* adds the import entry, but if its an existing import entry then preserves the comments surrounding the import
		642	*/
		643	private ImportDeclEntry addImportDeclEntry(String containerName, String fullTypeName, boolean isStatic, CompilationUnit root) {
		644	List/ImportDeclaration/ decls= root.imports();
		645	if (decls.isEmpty() \|\| this.preserveExistingCommentsRanges == null \|\| this.preserveExistingCommentsRanges.length == 0) {
		646	return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null);
		647	}
		648	IRegion precedingCommentRange = null;
		649	IRegion trailingCommentRange = null;
		650	int prevOffset = this.replaceRange.getOffset(); // will store offset of the previous import's extended end
		651	int numOfImports = decls.size();
		652	for (int i= 0; i < numOfImports; i++) {
		653	ImportDeclaration curr= (ImportDeclaration) decls.get(i);
		654	int currOffset= curr.getStartPosition();
		655	int currLength= curr.getLength();
		656	int currExtendedStart = root.getExtendedStartPosition(curr);
		657	int currExtendedLen = root.getExtendedLength(curr);
		658	String name= getFullName(curr);
		659	String packName= getQualifier(curr);
		660	if (packName.equals(containerName) && (name.equals(fullTypeName) \|\| name.endsWith("*"))) {//$NON-NLS-1$
		661	int preserveCommentsLen = this.preserveExistingCommentsRanges.length;
		662	for (int j = 0; j < preserveCommentsLen; j++) {
		663	int offset = this.preserveExistingCommentsRanges[j].getOffset();
		664	boolean wasRangeUsed = false;
		665	int existingCommentLength = this.preserveExistingCommentsRanges[j].getLength();
		666	if (offset == currExtendedStart) {
		667	// comments belonging to this import's extended start
		668	precedingCommentRange = new Region(offset, existingCommentLength);
		669	wasRangeUsed = true;
		670	} else if (offset < currExtendedStart && offset > prevOffset) {
		671	// comment between two imports but not inside either's extended ranges
		672	// to preserve the position of these comments add a dummy comment entry
		673	PackageEntry commentEntry = new PackageEntry(); // create a comment package entry for this
		674	commentEntry.setGroupID(packName); // the comment should belong to the current group
		675	this.packageEntries.add(commentEntry);
		676	commentEntry.add(new ImportDeclEntry(packName.length(), null, false, new Region(offset, existingCommentLength)));
		677	wasRangeUsed = true;
		678	} else if ((currExtendedStart + currExtendedLen) != (currOffset + currLength)){
		679	if (offset == currOffset + currLength) {
		680	// comment is in the extended end of the import
		681	trailingCommentRange = new Region(offset, existingCommentLength);
		682	wasRangeUsed = true;
		683	} else if (offset > (currOffset + currLength)) {
		684	break;
		685	}
		686	}
		687	if (wasRangeUsed) {
		688	// remove this comment from preserveExistingCommentsRanges array
		689	IRegion[] tempRegions = new IRegion[--preserveCommentsLen];
		690	System.arraycopy(this.preserveExistingCommentsRanges, 0, tempRegions, 0, j);
		691	System.arraycopy(this.preserveExistingCommentsRanges, j+1, tempRegions, j, tempRegions.length - j);
		692	this.preserveExistingCommentsRanges = tempRegions;
		693	j--;
		694	}
		695	}
		696	return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null, precedingCommentRange, trailingCommentRange);
		697	}
		698	prevOffset = currExtendedStart + currExtendedLen - 1;
		699	}
		700	return new ImportDeclEntry(containerName.length(), fullTypeName, isStatic, null);
623	}	701	}
624		702
625	public boolean removeImport(String qualifiedName, boolean isStatic) {	703	public boolean removeImport(String qualifiedName, boolean isStatic) {
Lines 748-763 Link Here
748	continue;	826	continue;
749	}	827	}
750		828
751	if (spacesBetweenGroups > 0) {	829	if (spacesBetweenGroups > 0 && lastPackage != null) {
752	// add a space between two different groups by looking at the two adjacent imports	830	// add a space between two different groups by looking at the two adjacent imports
753	if (lastPackage != null && !pack.isComment() && !pack.isSameGroup(lastPackage)) {	831	if (!lastPackage.isComment() && !pack.isComment() && !pack.isSameGroup(lastPackage)) {
754	ImportDeclEntry last= lastPackage.getImportAt(lastPackage.getNumberOfImports() - 1);	832	for (int k= spacesBetweenGroups; k > 0; k--) {
755	ImportDeclEntry first= pack.getImportAt(0);	833	stringsToInsert.add(lineDelim);
756	if (!lastPackage.isComment() && (last.isNew() \|\| first.isNew())) {
757	for (int k= spacesBetweenGroups; k > 0; k--) {
758	stringsToInsert.add(lineDelim);
759	}
760	}	834	}
		835	} else if (lastPackage.isComment() && pack.isSameGroup(lastPackage)) {
		836	// the last pack may be a dummy for a comment which doesn't belong to any extended range
		837	stringsToInsert.add(lineDelim);
761	}	838	}
762	}	839	}
763	lastPackage= pack;	840	lastPackage= pack;
Lines 766-787 Link Here
766	int threshold= isStatic ? this.staticImportOnDemandThreshold : this.importOnDemandThreshold;	843	int threshold= isStatic ? this.staticImportOnDemandThreshold : this.importOnDemandThreshold;
767		844
768	boolean doStarImport= pack.hasStarImport(threshold, onDemandConflicts);	845	boolean doStarImport= pack.hasStarImport(threshold, onDemandConflicts);
		846	boolean allImportsAddedToStar = false;
769	if (doStarImport && (pack.find("*") == null)) { //$NON-NLS-1$	847	if (doStarImport && (pack.find("*") == null)) { //$NON-NLS-1$
770	String[] imports = getNewImportStrings(buffer, pack, isStatic, lineDelim);	848	String[] imports = getNewImportStrings(buffer, pack, isStatic, lineDelim);
771	for (int j = 0, max = imports.length; j < max; j++) {	849	for (int j = 0, max = imports.length; j < max; j++) {
772	stringsToInsert.add(imports[j]);	850	stringsToInsert.add(imports[j]);
773	}	851	}
		852	allImportsAddedToStar = true; // may still need to handle onDemandConflicts below
774	}	853	}
775		854
776	for (int k= 0; k < nImports; k++) {	855	for (int k= 0; k < nImports; k++) {
777	ImportDeclEntry currDecl= pack.getImportAt(k);	856	ImportDeclEntry currDecl= pack.getImportAt(k);
778	IRegion region= currDecl.getSourceRange();	857	IRegion region= currDecl.getSourceRange();
779		858	boolean isConflict = !currDecl.isComment() && onDemandConflicts != null && onDemandConflicts.contains(currDecl.getSimpleName());
		859	boolean addRegularToStar = doStarImport && !currDecl.isOnDemand();
		860
780	if (region == null) { // new entry	861	if (region == null) { // new entry
781	if (!doStarImport \|\| currDecl.isOnDemand() \|\| (onDemandConflicts != null && onDemandConflicts.contains(currDecl.getSimpleName()))) {	862	if (!addRegularToStar \|\| isConflict) {
782	String str= getNewImportString(currDecl.getElementName(), isStatic, lineDelim);	863	IRegion rangeBefore = currDecl.getPrecedingCommentRange();
		864	IRegion rangeAfter = currDecl.getTrailingCommentRange();
		865	if (rangeBefore != null) {
		866	stringsToInsert.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
		867	}
		868
		869	String trailingComment = null;
		870	if (rangeAfter != null) {
		871	trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
		872	}
		873	String str= getNewImportString(currDecl.getElementName(), isStatic, trailingComment, lineDelim);
783	stringsToInsert.add(str);	874	stringsToInsert.add(str);
784	} else if (doStarImport && !currDecl.isOnDemand()) {	875	} else if (addRegularToStar && !allImportsAddedToStar) {
785	String simpleName = currDecl.getTypeQualifiedName();	876	String simpleName = currDecl.getTypeQualifiedName();
786	if (simpleName.indexOf('.') != -1) {	877	if (simpleName.indexOf('.') != -1) {
787	String str= getNewImportString(currDecl.getElementName(), isStatic, lineDelim);	878	String str= getNewImportString(currDecl.getElementName(), isStatic, lineDelim);
Lines 790-796 Link Here
790	}	881	}
791	}	882	}
792	}	883	}
793	} else if (!doStarImport \|\| currDecl.isOnDemand() \|\| onDemandConflicts == null \|\| onDemandConflicts.contains(currDecl.getSimpleName())) {	884	} else if (!addRegularToStar \|\| isConflict) {
794	int offset= region.getOffset();	885	int offset= region.getOffset();
795	IRegion rangeBefore = currDecl.getPrecedingCommentRange();	886	IRegion rangeBefore = currDecl.getPrecedingCommentRange();
796	if (rangeBefore != null && currPos > rangeBefore.getOffset()) {	887	if (rangeBefore != null && currPos > rangeBefore.getOffset()) {
Lines 803-809 Link Here
803	removeAndInsertNew(buffer, currPos, offset, stringsToInsert, resEdit);	894	removeAndInsertNew(buffer, currPos, offset, stringsToInsert, resEdit);
804	stringsToInsert.clear();	895	stringsToInsert.clear();
805	currPos= offset + region.getLength();	896	currPos= offset + region.getLength();
806	} else if (doStarImport && !currDecl.isOnDemand()) {	897	} else if (addRegularToStar && !allImportsAddedToStar && !currDecl.isComment()) {
807	String simpleName = currDecl.getTypeQualifiedName();	898	String simpleName = currDecl.getTypeQualifiedName();
808	if (simpleName.indexOf('.') != -1) {	899	if (simpleName.indexOf('.') != -1) {
809	IRegion rangeBefore = currDecl.getPrecedingCommentRange();	900	IRegion rangeBefore = currDecl.getPrecedingCommentRange();
Lines 830-836 Link Here
830		921
831	// insert back all existing imports comments since existing imports were not preserved	922	// insert back all existing imports comments since existing imports were not preserved
832	if (this.preserveExistingCommentsRanges != null) {	923	if (this.preserveExistingCommentsRanges != null) {
833	for (int i = 0, max = this.preserveExistingCommentsRanges.length; i < max; i++) {	924	for (int i = 0, max = this.preserveExistingCommentsRanges.length; (i < max && this.preserveExistingCommentsRanges[i] != null); i++) {
834	IRegion region = this.preserveExistingCommentsRanges[i];	925	IRegion region = this.preserveExistingCommentsRanges[i];
835	String text = buffer.getText(region.getOffset(), region.getLength());	926	String text = buffer.getText(region.getOffset(), region.getLength());
836	// remove preceding whitespaces	927	// remove preceding whitespaces
Lines 1012-1022 Link Here
1012	List allImports = new ArrayList();	1103	List allImports = new ArrayList();
1013	int nImports = packageEntry.getNumberOfImports();	1104	int nImports = packageEntry.getNumberOfImports();
1014	StringBuffer allComments = null;	1105	StringBuffer allComments = null;
		1106	StringBuffer allCommentsLead = null;
1015	for (int i= 0; i < nImports; i++) {	1107	for (int i= 0; i < nImports; i++) {
1016	ImportDeclEntry curr= packageEntry.getImportAt(i);	1108	ImportDeclEntry curr= packageEntry.getImportAt(i);
1017	String simpleName = curr.getTypeQualifiedName();	1109	if (curr.isComment()) {
1018	if (simpleName.indexOf('.') != -1) {
1019	// member type imports - we preserve it
1020	IRegion rangeBefore = curr.getPrecedingCommentRange();	1110	IRegion rangeBefore = curr.getPrecedingCommentRange();
1021	if (rangeBefore != null) {	1111	if (rangeBefore != null) {
1022	allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));	1112	allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
Lines 1026-1056 Link Here
1026	if (rangeAfter != null) {	1116	if (rangeAfter != null) {
1027	trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());	1117	trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
1028	}	1118	}
1029	allImports.add(getNewImportString(curr.getElementName(), isStatic, trailingComment, lineDelim));	1119	if (trailingComment != null) {
1030	} else if (!isStarImportAdded) {	1120	allImports.add(buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength()));
1031	String starImportString= packageEntry.getName() + ".*"; //$NON-NLS-1$
1032	allImports.add(getNewImportString(starImportString, isStatic, lineDelim));
1033	isStarImportAdded = true;
1034	} else {
1035	// collect all comments
1036	IRegion rangeBefore = curr.getPrecedingCommentRange();
1037	if (rangeBefore != null) {
1038	if (allComments == null) {
1039	allComments = new StringBuffer();
1040	}
1041	allComments.append(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength())).append(lineDelim);
1042	}	1121	}
1043	IRegion rangeAfter = curr.getTrailingCommentRange();	1122	} else {
1044	if (rangeAfter != null) {	1123	String simpleName = curr.getTypeQualifiedName();
1045	if (allComments == null) {	1124	if (simpleName.indexOf('.') != -1) {
1046	allComments = new StringBuffer();	1125	// member type imports - we preserve it
		1126	IRegion rangeBefore = curr.getPrecedingCommentRange();
		1127	if (rangeBefore != null) {
		1128	allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
1047	}	1129	}
1048	allComments.append(buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength())).append(lineDelim);	1130	IRegion rangeAfter = curr.getTrailingCommentRange();
		1131	String trailingComment = null;
		1132	if (rangeAfter != null) {
		1133	trailingComment = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
		1134	}
		1135	allImports.add(getNewImportString(curr.getElementName(), isStatic, trailingComment, lineDelim));
		1136	} else if (!isStarImportAdded) {
		1137	String starImportString= packageEntry.getName() + ".*"; //$NON-NLS-1$
		1138	// collect all comments
		1139	IRegion rangeBefore = curr.getPrecedingCommentRange();
		1140	if (rangeBefore != null) {
		1141	allImports.add(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
		1142	}
		1143	IRegion rangeAfter = curr.getTrailingCommentRange();
		1144	String trailComments = null;
		1145	if (rangeAfter != null) {
		1146	trailComments = buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength());
		1147	}
		1148	allImports.add(getNewImportString(starImportString, isStatic, trailComments, lineDelim));
		1149	isStarImportAdded = true;
		1150	} else {
		1151	// collect all comments
		1152	IRegion rangeBefore = curr.getPrecedingCommentRange();
		1153	if (rangeBefore != null) {
		1154	if (allCommentsLead == null) {
		1155	allCommentsLead = new StringBuffer();
		1156	}
		1157	allCommentsLead.append(buffer.getText(rangeBefore.getOffset(), rangeBefore.getLength()));
		1158	}
		1159	IRegion rangeAfter = curr.getTrailingCommentRange();
		1160	if (rangeAfter != null) {
		1161	if (allComments == null) {
		1162	allComments = new StringBuffer();
		1163	}
		1164	allComments.append(buffer.getText(rangeAfter.getOffset(), rangeAfter.getLength()));
		1165	}
1049	}	1166	}
1050	}	1167	}
1051	}	1168	}
		1169	if (allCommentsLead != null) {
		1170	allImports.add(0, String.valueOf(allCommentsLead));
		1171	}
1052	if (allComments != null) {	1172	if (allComments != null) {
1053	allImports.add(0, String.valueOf(allComments));	1173	allImports.add(String.valueOf(allComments.append(lineDelim)));
1054	}	1174	}
1055	return (String[]) allImports.toArray(new String[allImports.size()]);	1175	return (String[]) allImports.toArray(new String[allImports.size()]);
1056	}	1176	}
Lines 1110-1117 Link Here
1110	private IRegion sourceRange;	1230	private IRegion sourceRange;
1111	private final boolean isStatic;	1231	private final boolean isStatic;
1112	private int containerNameLength;	1232	private int containerNameLength;
1113	private IRegion precedingCommentRange;	1233	IRegion precedingCommentRange;
1114	private IRegion trailingCommentRange;	1234	IRegion trailingCommentRange;
1115		1235
1116	public ImportDeclEntry(	1236	public ImportDeclEntry(
1117	int containerNameLength,	1237	int containerNameLength,
Lines 1371-1380 Link Here
1371	for (int i= 0; i < nImports; i++) {	1491	for (int i= 0; i < nImports; i++) {
1372	ImportDeclEntry curr= getImportAt(i);	1492	ImportDeclEntry curr= getImportAt(i);
1373	buf.append(" "); //$NON-NLS-1$	1493	buf.append(" "); //$NON-NLS-1$
1374	if (curr.isStatic()) {	1494	if (curr.isComment()) {
1375	buf.append("static "); //$NON-NLS-1$	1495	buf.append("comment"); //$NON-NLS-1$
		1496	} else {
		1497	if (curr.isStatic()) {
		1498	buf.append("static "); //$NON-NLS-1$
		1499	}
		1500	buf.append(curr.getTypeQualifiedName());
1376	}	1501	}
1377	buf.append(curr.getTypeQualifiedName());
1378	if (curr.isNew()) {	1502	if (curr.isNew()) {
1379	buf.append(" (new)"); //$NON-NLS-1$	1503	buf.append(" (new)"); //$NON-NLS-1$
1380	}	1504	}