Attachment #157791 for bug #235253




	private String[] createdStaticImports;

	private boolean filterImplicitImports;
	private boolean mainTypeTypesAreImplicitImports;

	/**
	 * Creates a {@link ImportRewrite} from a {@link ICompilationUnit}. If <code>restoreExistingImports</code>

			this.restoreExistingImports= false;
		}
		this.filterImplicitImports= true;
		this.mainTypeTypesAreImplicitImports= true;

		this.defaultContext= new ImportRewriteContext() {
			public int findInContext(String qualifier, String name, int kind) {

	}

	/**
	 * Specifies that implicit imports (for types in <code>java.lang</code>, types in the same package as the rewrite
	 * compilation unit, and types in the compilation unit's main type) should not be created, except if necessary to
	 * resolve an on-demand import conflict.
	 * <p>
	 * The filter is enabled by default.
	 * </p>
	 * <p>
	 * Note: {@link #setMainTypeTypesAreImplicitImports(boolean)} can be used to stop filtering types in the compilation
	 * unit's main type.
	 * </p>
	 * 
	 * @param filterImplicitImports
	 *            if <code>true</code>, implicit imports will be filtered
	 * 
	 * @see #setMainTypeTypesAreImplicitImports(boolean)
	 */
	public void setFilterImplicitImports(boolean filterImplicitImports) {
		this.filterImplicitImports= filterImplicitImports;
	}

	/**
	 * Sets whether types in the compilation unit's main type are considered as implicit imports when
	 * {@link #setFilterImplicitImports(boolean)} is enabled.
	 * <p>
	 * By default, the option is enabled, i.e. types in the compilation unit's main type are considered as implicit
	 * imports. Note that this interpretation is only correct for type references inside direct children of the main
	 * type
	 * </p>
	 * 
	 * @param mainTypeTypesAreImplicitImports
	 *            the mainTypeTypesAreImplicitImports to set
	 * 
	 * @see #setFilterImplicitImports(boolean)
	 * @since 3.6
	 */
	public void setMainTypeTypesAreImplicitImports(boolean mainTypeTypesAreImplicitImports) {
		this.mainTypeTypesAreImplicitImports= mainTypeTypesAreImplicitImports;
	}
	
	private static int compareImport(char prefix, String qualifier, String name, String curr) {
		if (curr.charAt(0) != prefix || !curr.endsWith(name)) {
			return ImportRewriteContext.RES_NAME_UNKNOWN;


			ImportRewriteAnalyzer computer= new ImportRewriteAnalyzer(this.compilationUnit, usedAstRoot, this.importOrder, this.importOnDemandThreshold, this.staticImportOnDemandThreshold, this.restoreExistingImports);
			computer.setFilterImplicitImports(this.filterImplicitImports);
			computer.setMainTypeTypesAreImplicitImports(this.mainTypeTypesAreImplicitImports);

			if (this.addedImports != null) {
				for (int i= 0; i < this.addedImports.size(); i++) {




	private final int staticImportOnDemandThreshold;

	private boolean filterImplicitImports;
	private boolean mainTypeTypesAreImplicitImports;
	private boolean findAmbiguousImports;

	private int flags= 0;

		this.staticImportOnDemandThreshold= staticThreshold;

		this.filterImplicitImports= true;
		this.mainTypeTypesAreImplicitImports= true;
		this.findAmbiguousImports= true; //!restoreExistingImports;

		this.packageEntries= new ArrayList(20);

	}

	/**
	 * Specifies that implicit imports (for types in <code>java.lang</code>, types in the same package as the rewrite
	 * compilation unit and types in the compilation unit's main type) should not be created, except if necessary to
	 * resolve an on-demand import conflict.
	 * <p>
	 * The filter is enabled by default.
	 * </p>
	 * <p>
	 * Note: {@link #setMainTypeTypesAreImplicitImports(boolean)} can be used to stop filtering types in the compilation
	 * unit's main type.
	 * </p>
	 * 
	 * @param filterImplicitImports
	 *            if <code>true</code>, implicit imports will be filtered
	 * 
	 * @see #setMainTypeTypesAreImplicitImports(boolean)
	 */
	public void setFilterImplicitImports(boolean filterImplicitImports) {
		this.filterImplicitImports= filterImplicitImports;
	}

	/**
	 * Sets whether types in the compilation unit's main type are considered as implicit imports when
	 * {@link #setFilterImplicitImports(boolean)} is enabled. By default, the option is enabled, i.e. types in the
	 * compilation unit's main type are considered as implicit imports.
	 * 
	 * @param mainTypeTypesAreImplicitImports
	 *            the mainTypeTypesAreImplicitImports to set
	 * 
	 * @see #setFilterImplicitImports(boolean)
	 * @since 3.6
	 */
	public void setMainTypeTypesAreImplicitImports(boolean mainTypeTypesAreImplicitImports) {
		this.mainTypeTypesAreImplicitImports= mainTypeTypesAreImplicitImports;
	}

	/**
	 * When set searches for imports that can not be folded into on-demand
	 * imports but must be specified explicitly
	 * @param findAmbiguousImports The new value

		return bestMatch;
	}

	private boolean isImplicitImport(String qualifier) {
		if (JAVA_LANG.equals(qualifier)) {
			return true;
		}
		ICompilationUnit cu= this.compilationUnit;
		String packageName= cu.getParent().getElementName();
		if (qualifier.equals(packageName)) {
			return true;
		}

		if (!this.mainTypeTypesAreImplicitImports) {
			return false;
		}

		String mainTypeName= JavaCore.removeJavaLikeExtension(cu.getElementName());
		if (packageName.length() == 0) {
			return qualifier.equals(mainTypeName);

				PackageEntry pack= (PackageEntry) this.packageEntries.get(i);
				int nImports= pack.getNumberOfImports();

				if (this.filterImplicitImports && !pack.isStatic() && isImplicitImport(pack.getName())) {
					pack.removeAllNew(onDemandConflicts);
					nImports= pack.getNumberOfImports();
				}

Lines 425-430 Link Here

(-)core extension/org/eclipse/jdt/internal/corext/codemanipulation/OrganizeImportsOperation.java (+1 lines)
425	}	425	}
426		426
427	ImportRewrite importsRewrite= StubUtility.createImportRewrite(astRoot, false);	427	ImportRewrite importsRewrite= StubUtility.createImportRewrite(astRoot, false);
		428	importsRewrite.setMainTypeTypesAreImplicitImports(false);
428		429
429	Set/<String>/ oldSingleImports= new HashSet();	430	Set/<String>/ oldSingleImports= new HashSet();
430	Set/<String>/ oldDemandImports= new HashSet();	431	Set/<String>/ oldDemandImports= new HashSet();

Return to bug 235253

Lines 137-142 Link Here

(-)dom/org/eclipse/jdt/core/dom/rewrite/ImportRewrite.java (-4 / +37 lines)
137	private String[] createdStaticImports;	137	private String[] createdStaticImports;
138		138
139	private boolean filterImplicitImports;	139	private boolean filterImplicitImports;
		140	private boolean mainTypeTypesAreImplicitImports;
140		141
141	/**	142	/**
142	* Creates a {@link ImportRewrite} from a {@link ICompilationUnit}. If <code>restoreExistingImports</code>	143	* Creates a {@link ImportRewrite} from a {@link ICompilationUnit}. If <code>restoreExistingImports</code>
Lines 221-226 Link Here
221	this.restoreExistingImports= false;	222	this.restoreExistingImports= false;
222	}	223	}
223	this.filterImplicitImports= true;	224	this.filterImplicitImports= true;
		225	this.mainTypeTypesAreImplicitImports= true;
224		226
225	this.defaultContext= new ImportRewriteContext() {	227	this.defaultContext= new ImportRewriteContext() {
226	public int findInContext(String qualifier, String name, int kind) {	228	public int findInContext(String qualifier, String name, int kind) {
Lines 303-317 Link Here
303	}	305	}
304		306
305	/**	307	/**
306	* Specifies that implicit imports (types in default package, package <code>java.lang</code> or	308	* Specifies that implicit imports (for types in <code>java.lang</code>, types in the same package as the rewrite
307	* in the same package as the rewrite compilation unit should not be created except if necessary	309	* compilation unit, and types in the compilation unit's main type) should not be created, except if necessary to
308	* to resolve an on-demand import conflict. The filter is enabled by default.	310	* resolve an on-demand import conflict.
309	* @param filterImplicitImports if set, implicit imports will be filtered.	311	* <p>
		312	* The filter is enabled by default.
		313	* </p>
		314	* <p>
		315	* Note: {@link #setMainTypeTypesAreImplicitImports(boolean)} can be used to stop filtering types in the compilation
		316	* unit's main type.
		317	* </p>
		318	*
		319	* @param filterImplicitImports
		320	* if <code>true</code>, implicit imports will be filtered
		321	*
		322	* @see #setMainTypeTypesAreImplicitImports(boolean)
310	*/	323	*/
311	public void setFilterImplicitImports(boolean filterImplicitImports) {	324	public void setFilterImplicitImports(boolean filterImplicitImports) {
312	this.filterImplicitImports= filterImplicitImports;	325	this.filterImplicitImports= filterImplicitImports;
313	}	326	}
314		327
		328	/**
		329	* Sets whether types in the compilation unit's main type are considered as implicit imports when
		330	* {@link #setFilterImplicitImports(boolean)} is enabled.
		331	* <p>
		332	* By default, the option is enabled, i.e. types in the compilation unit's main type are considered as implicit
		333	* imports. Note that this interpretation is only correct for type references inside direct children of the main
		334	* type
		335	* </p>
		336	*
		337	* @param mainTypeTypesAreImplicitImports
		338	* the mainTypeTypesAreImplicitImports to set
		339	*
		340	* @see #setFilterImplicitImports(boolean)
		341	* @since 3.6
		342	*/
		343	public void setMainTypeTypesAreImplicitImports(boolean mainTypeTypesAreImplicitImports) {
		344	this.mainTypeTypesAreImplicitImports= mainTypeTypesAreImplicitImports;
		345	}
		346
315	private static int compareImport(char prefix, String qualifier, String name, String curr) {	347	private static int compareImport(char prefix, String qualifier, String name, String curr) {
316	if (curr.charAt(0) != prefix \|\| !curr.endsWith(name)) {	348	if (curr.charAt(0) != prefix \|\| !curr.endsWith(name)) {
317	return ImportRewriteContext.RES_NAME_UNKNOWN;	349	return ImportRewriteContext.RES_NAME_UNKNOWN;
Lines 995-1000 Link Here
995		1027
996	ImportRewriteAnalyzer computer= new ImportRewriteAnalyzer(this.compilationUnit, usedAstRoot, this.importOrder, this.importOnDemandThreshold, this.staticImportOnDemandThreshold, this.restoreExistingImports);	1028	ImportRewriteAnalyzer computer= new ImportRewriteAnalyzer(this.compilationUnit, usedAstRoot, this.importOrder, this.importOnDemandThreshold, this.staticImportOnDemandThreshold, this.restoreExistingImports);
997	computer.setFilterImplicitImports(this.filterImplicitImports);	1029	computer.setFilterImplicitImports(this.filterImplicitImports);
		1030	computer.setMainTypeTypesAreImplicitImports(this.mainTypeTypesAreImplicitImports);
998		1031
999	if (this.addedImports != null) {	1032	if (this.addedImports != null) {
1000	for (int i= 0; i < this.addedImports.size(); i++) {	1033	for (int i= 0; i < this.addedImports.size(); i++) {

Lines 53-58 Link Here

(-)dom/org/eclipse/jdt/internal/core/dom/rewrite/ImportRewriteAnalyzer.java (-8 / +40 lines)
53	private final int staticImportOnDemandThreshold;	53	private final int staticImportOnDemandThreshold;
54		54
55	private boolean filterImplicitImports;	55	private boolean filterImplicitImports;
		56	private boolean mainTypeTypesAreImplicitImports;
56	private boolean findAmbiguousImports;	57	private boolean findAmbiguousImports;
57		58
58	private int flags= 0;	59	private int flags= 0;
Lines 68-73 Link Here
68	this.staticImportOnDemandThreshold= staticThreshold;	69	this.staticImportOnDemandThreshold= staticThreshold;
69		70
70	this.filterImplicitImports= true;	71	this.filterImplicitImports= true;
		72	this.mainTypeTypesAreImplicitImports= true;
71	this.findAmbiguousImports= true; //!restoreExistingImports;	73	this.findAmbiguousImports= true; //!restoreExistingImports;
72		74
73	this.packageEntries= new ArrayList(20);	75	this.packageEntries= new ArrayList(20);
Lines 238-255 Link Here
238	}	240	}
239		241
240	/**	242	/**
241	* Sets that implicit imports (types in default package, CU- package and	243	* Specifies that implicit imports (for types in <code>java.lang</code>, types in the same package as the rewrite
242	* 'java.lang') should not be created. Note that this is a heuristic filter and can	244	* compilation unit and types in the compilation unit's main type) should not be created, except if necessary to
243	* lead to missing imports, e.g. in cases where a type is forced to be specified	245	* resolve an on-demand import conflict.
244	* due to a name conflict.	246	* <p>
245	* By default, the filter is enabled.	247	* The filter is enabled by default.
246	* @param filterImplicitImports The filterImplicitImports to set	248	* </p>
		249	* <p>
		250	* Note: {@link #setMainTypeTypesAreImplicitImports(boolean)} can be used to stop filtering types in the compilation
		251	* unit's main type.
		252	* </p>
		253	*
		254	* @param filterImplicitImports
		255	* if <code>true</code>, implicit imports will be filtered
		256	*
		257	* @see #setMainTypeTypesAreImplicitImports(boolean)
247	*/	258	*/
248	public void setFilterImplicitImports(boolean filterImplicitImports) {	259	public void setFilterImplicitImports(boolean filterImplicitImports) {
249	this.filterImplicitImports= filterImplicitImports;	260	this.filterImplicitImports= filterImplicitImports;
250	}	261	}
251		262
252	/**	263	/**
		264	* Sets whether types in the compilation unit's main type are considered as implicit imports when
		265	* {@link #setFilterImplicitImports(boolean)} is enabled. By default, the option is enabled, i.e. types in the
		266	* compilation unit's main type are considered as implicit imports.
		267	*
		268	* @param mainTypeTypesAreImplicitImports
		269	* the mainTypeTypesAreImplicitImports to set
		270	*
		271	* @see #setFilterImplicitImports(boolean)
		272	* @since 3.6
		273	*/
		274	public void setMainTypeTypesAreImplicitImports(boolean mainTypeTypesAreImplicitImports) {
		275	this.mainTypeTypesAreImplicitImports= mainTypeTypesAreImplicitImports;
		276	}
		277
		278	/**
253	* When set searches for imports that can not be folded into on-demand	279	* When set searches for imports that can not be folded into on-demand
254	* imports but must be specified explicitly	280	* imports but must be specified explicitly
255	* @param findAmbiguousImports The new value	281	* @param findAmbiguousImports The new value
Lines 385-398 Link Here
385	return bestMatch;	411	return bestMatch;
386	}	412	}
387		413
388	private static boolean isImplicitImport(String qualifier, ICompilationUnit cu) {	414	private boolean isImplicitImport(String qualifier) {
389	if (JAVA_LANG.equals(qualifier)) {	415	if (JAVA_LANG.equals(qualifier)) {
390	return true;	416	return true;
391	}	417	}
		418	ICompilationUnit cu= this.compilationUnit;
392	String packageName= cu.getParent().getElementName();	419	String packageName= cu.getParent().getElementName();
393	if (qualifier.equals(packageName)) {	420	if (qualifier.equals(packageName)) {
394	return true;	421	return true;
395	}	422	}
		423
		424	if (!this.mainTypeTypesAreImplicitImports) {
		425	return false;
		426	}
		427
396	String mainTypeName= JavaCore.removeJavaLikeExtension(cu.getElementName());	428	String mainTypeName= JavaCore.removeJavaLikeExtension(cu.getElementName());
397	if (packageName.length() == 0) {	429	if (packageName.length() == 0) {
398	return qualifier.equals(mainTypeName);	430	return qualifier.equals(mainTypeName);
Lines 524-530 Link Here
524	PackageEntry pack= (PackageEntry) this.packageEntries.get(i);	556	PackageEntry pack= (PackageEntry) this.packageEntries.get(i);
525	int nImports= pack.getNumberOfImports();	557	int nImports= pack.getNumberOfImports();
526		558
527	if (this.filterImplicitImports && !pack.isStatic() && isImplicitImport(pack.getName(), this.compilationUnit)) {	559	if (this.filterImplicitImports && !pack.isStatic() && isImplicitImport(pack.getName())) {
528	pack.removeAllNew(onDemandConflicts);	560	pack.removeAllNew(onDemandConflicts);
529	nImports= pack.getNumberOfImports();	561	nImports= pack.getNumberOfImports();
530	}	562	}