Attachment #78555 for bug #146852

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 146852
Collapse All | Expand All

Lines 180-186 Link Here

(-)a/java.j2seproject/nbproject/project.xml (-1 / +1 lines)
180	<compile-dependency/>	180	<compile-dependency/>
181	<run-dependency>	181	<run-dependency>
182	<release-version>1</release-version>	182	<release-version>1</release-version>
183	<specification-version>1.28</specification-version>	183	<specification-version>1.31</specification-version>
184	</run-dependency>	184	</run-dependency>
185	</dependency>	185	</dependency>
186	<dependency>	186	<dependency>




    private final PropertyEvaluator eval;
    private final ReferenceHelper refHelper;
    private final GeneratedFilesHelper genFilesHelper;
    private Lookup lookup;
    private final UpdateHelper updateHelper;
    private MainClassUpdater mainClassUpdater;
    private SourceRoots sourceRoots;

            UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
            QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
            QuerySupport.createSourceLevelQuery(evaluator()),
            new J2SESources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
            new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
            new RecommendedTemplatesImpl (this.updateHelper),

            LookupMergerSupport.createJFBLookupMerger(),
            QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata
        );
        lookup = base; // in case LookupProvider's call Project.getLookup
        return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N
    }
    




import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.Project;
import org.netbeans.modules.java.api.common.SourceRoots;
import org.netbeans.modules.java.api.common.project.ProjectProperties;
import org.netbeans.spi.project.support.GenericSources;

    private static final String BUILD_DIR_PROP = "${" + J2SEProjectProperties.BUILD_DIR + "}";    //NOI18N
    private static final String DIST_DIR_PROP = "${" + J2SEProjectProperties.DIST_DIR + "}";    //NOI18N

    private final Project project;
    private final AntProjectHelper helper;
    private final PropertyEvaluator evaluator;
    private final SourceRoots sourceRoots;
    private final SourceRoots testRoots;
    private SourcesHelper sourcesHelper;
    private Sources delegate;
    /**
     * Flag to forbid multiple invocation of {@link SourcesHelper#registerExternalRoots} 
     **/
    private boolean externalRootsRegistered;    
    private final ChangeSupport changeSupport = new ChangeSupport(this);

    J2SESources(Project project, AntProjectHelper helper, PropertyEvaluator evaluator,
                SourceRoots sourceRoots, SourceRoots testRoots) {
        this.project = project;
        this.helper = helper;
        this.evaluator = evaluator;
        this.sourceRoots = sourceRoots;

    }
    
    private Sources initSources() {
        this.sourcesHelper = new SourcesHelper(project, helper, evaluator);   //Safe to pass APH        
        register(sourceRoots);
        register(testRoots);
        this.sourcesHelper.addNonSourceRoot(BUILD_DIR_PROP);
        this.sourcesHelper.addNonSourceRoot(DIST_DIR_PROP);
        sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);
        ProjectManager.mutex().postWriteRequest(new Runnable() {
            public void run() {                
                if (!externalRootsRegistered) {
                    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT, false);
                    externalRootsRegistered = true;
                }
            }
        });
        return this.sourcesHelper.createSources();
    }





    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>

        <change id="SourcesHelper-Project-constructor">
            <api name="general"/>
            <summary>Added <code>SourcesHelper</code> constructor accepting <code>Project</code></summary>
            <version major="1" minor="31"/>
            <date day="27" month="3" year="2009"/>
            <author login="tzezula"/>
            <compatibility addition="yes" deprecation="yes"/>
            <description>
                <p>
                    The new constructor enables simplified control flow.
                </p>
            </description>
            <class package="org.netbeans.spi.project.support.ant" name="SourcesHelper"/>
            <issue number="146852"/>
        </change>
        
        <change id="antbasedprojectregistration">
            <api name="general"/>

Lines 1-6 Link Here

(-)a/project.ant/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.project.ant/1	2	OpenIDE-Module: org.netbeans.modules.project.ant/1
3	OpenIDE-Module-Specification-Version: 1.30	3	OpenIDE-Module-Specification-Version: 1.31
4	OpenIDE-Module-Layer: org/netbeans/modules/project/ant/resources/mf-layer.xml	4	OpenIDE-Module-Layer: org/netbeans/modules/project/ant/resources/mf-layer.xml
5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/project/ant/Bundle.properties	5	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/project/ant/Bundle.properties
6	OpenIDE-Module-Install: org/netbeans/modules/project/ant/AntProjectModule.class	6	OpenIDE-Module-Install: org/netbeans/modules/project/ant/AntProjectModule.class




import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileUtil;
import org.openide.util.ChangeSupport;
import org.openide.util.Parameters;
import org.openide.util.WeakListeners;

// XXX should perhaps be legal to call add* methods at any time (should update things)

            if (val == null) {
                return null;
            }
            return aph.resolveFile(val);
        }
        public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {
            File loc = getActualLocation();

        }
    }
    
    private final AntProjectHelper aph;
    private final Project project;
    private final PropertyEvaluator evaluator;
    private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();
    private final List<Root> nonSourceRoots = new ArrayList<Root>();

    /**
     * Create the helper object, initially configured to recognize only sources
     * contained inside the project directory.
     * @param aph an Ant project helper
     * @param evaluator a way to evaluate Ant properties used to define source locations
     * @deprecated Rather use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
     */
    @Deprecated
    public SourcesHelper(AntProjectHelper aph, PropertyEvaluator evaluator) {
        this.project = null;
        this.aph = aph;
        this.evaluator = evaluator;
    }
    
    /**
     * Create the helper object, initially configured to recognize only sources
     * contained inside the project directory.
     * @param project the project object (need not yet be registered in {@link ProjectManager})
     * @param aph an Ant project helper
     * @param evaluator a way to evaluate Ant properties used to define source locations
     * @since org.netbeans.modules.project.ant/1 1.31
     */
    public SourcesHelper(Project project, AntProjectHelper aph, PropertyEvaluator evaluator) {
        Parameters.notNull("project", project);
        this.project = project;
        this.aph = aph;
        this.evaluator = evaluator;
    }
    

    }
    
    private Project getProject() {
        return project != null ? project : AntBasedProjectFactorySingleton.getProjectFor(aph);
    }
    
    /**

     * {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.
     * </p>
     * <p>
     * If you used the old constructor form
     * {@link #SourcesHelper(AntProjectHelper, PropertyEvaluator)}
     * then you may <em>not</em> call this method inside the project's constructor, as
     * it requires the actual project to exist and be registered in {@link ProjectManager};
     * in this case you could still use {@link org.openide.util.Mutex#postWriteRequest} to run it
     * later, if you were creating the helper in your constructor, since the project construction
     * normally occurs in read access.
     * Better to use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
     * </p>
     * @param algorithm an external root registration algorithm as per
     *                  {@link FileOwnerQuery#markExternalOwner}

        allRoots.addAll(nonSourceRoots);
        allRoots.addAll(ownedFiles);
        Project p = getProject();
        FileObject pdir = aph.getProjectDirectory();
        // First time: register roots and add to lastRegisteredRoots.
        // Subsequent times: add to newRootsToRegister and maybe add them later.
        if (lastRegisteredRoots == null) {

Lines 95-100 Link Here

(-)a/projectapi/src/org/netbeans/modules/projectapi/AuxiliaryConfigBasedPreferencesProvider.java (+1 lines)
95	}	95	}
96		96
97	AuxiliaryConfiguration ac = ProjectUtils.getAuxiliaryConfiguration(p);	97	AuxiliaryConfiguration ac = ProjectUtils.getAuxiliaryConfiguration(p);
		98	assert p.getLookup() != null : p;
98	AuxiliaryProperties ap = p.getLookup().lookup(AuxiliaryProperties.class);	99	AuxiliaryProperties ap = p.getLookup().lookup(AuxiliaryProperties.class);
99		100
100	target.put(p, new WeakReference<AuxiliaryConfigBasedPreferencesProvider>(prov = new AuxiliaryConfigBasedPreferencesProvider(p, ac, ap, shared)));	101	target.put(p, new WeakReference<AuxiliaryConfigBasedPreferencesProvider>(prov = new AuxiliaryConfigBasedPreferencesProvider(p, ac, ap, shared)));




package org.netbeans.modules.projectimport.eclipse.core;

import java.util.concurrent.ExecutionException;
import java.util.logging.Logger;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.spi.project.ui.ProjectOpenedHook;
import org.openide.util.Exceptions;
import org.openide.util.RequestProcessor;

/**
 *
 */
public class ProjectOpenHookImpl extends ProjectOpenedHook{

    private static final RequestProcessor PROJ_OPEN_HOOK_RESYNCHRONIZER = new RequestProcessor("Eclipse.Resynchronizer"); // NOI18N
    private static RequestProcessor.Task currentTask;
    
    public ProjectOpenHookImpl() {}
    private Project project;
    
    private static final Logger LOG =
            Logger.getLogger(ProjectOpenHookImpl.class.getName());
    
    public ProjectOpenHookImpl(Project project, UpgradableProject upgradable) {
        this.upgradable = upgradable;
        this.project = project;
    }
    
    @Override
    protected synchronized void projectOpened() {




package org.netbeans.modules.projectimport.eclipse.core.spi;

import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.modules.projectimport.eclipse.core.ProjectOpenHookImpl;
import org.netbeans.modules.projectimport.eclipse.core.UpgradableProject;
import org.netbeans.spi.project.LookupProvider;
import org.openide.util.Lookup;
import org.openide.util.lookup.Lookups;

// registered separately in j2se and web modules, otherwise could use @LookupProvider.Registration
final public class UpgradableProjectLookupProvider implements LookupProvider {

    public Lookup createAdditionalLookup(Lookup baseContext) {
        Project p = baseContext.lookup(Project.class);
        assert p != null;
        if (ProjectUtils.getPreferences(p, UpgradableProjectLookupProvider.class, true).
                get("project", null) == null) { // NOI18N
            // Shortcut, the normal case:
            return Lookup.EMPTY;
        } else {
            // Keep as separate method to try to delay class initialization:
            return upgradeLookup(p);
        }
    }

    private static Lookup upgradeLookup(Project p) {
        return Lookups.fixed(
            new UpgradableProject(p),
            new ProjectOpenHookImpl());
    }

}




import java.util.Collections;
import java.util.List;
import org.netbeans.api.java.platform.JavaPlatform;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectManager;
import org.netbeans.api.project.ProjectUtils;

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        assertEquals(

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        assertEquals(

                model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
        List<String> importProblems = new ArrayList<String>();
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
        EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
        // required project "JavaLibrary1" is not available and therefore should not be

                mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);
        List<String> problems = new ArrayList<String>();
        J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());
        
        //
        // NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
        // 
        // Looks like J2SEProject registers its external source roots asynchronously and sometimes 
        // it is too late and above problem happens. Mark external source roots explicitly here:
        FileOwnerQuery.markExternalOwner(mdl_d.getEclipseSourceRootsAsFileArray()[0].toURI(), j2seprj_d, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
        
        ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);
        assertEquals(Collections.emptyList(), problems);
        assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));

Lines 185-191 Link Here

(-)a/web.project/src/org/netbeans/modules/web/project/WebProject.java (-1 / +2 lines)
185	private final PropertyEvaluator eval;	185	private final PropertyEvaluator eval;
186	private final ReferenceHelper refHelper;	186	private final ReferenceHelper refHelper;
187	private final GeneratedFilesHelper genFilesHelper;	187	private final GeneratedFilesHelper genFilesHelper;
188	private final Lookup lookup;	188	private Lookup lookup;
189	private final ProjectWebModule webModule;	189	private final ProjectWebModule webModule;
190	private final CopyOnSaveSupport css;	190	private final CopyOnSaveSupport css;
191	private final ArtifactCopyOnSaveSupport artifactSupport;	191	private final ArtifactCopyOnSaveSupport artifactSupport;
Lines 529-534 Link Here
529	LookupMergerSupport.createJFBLookupMerger(),	529	LookupMergerSupport.createJFBLookupMerger(),
530	QuerySupport.createBinaryForSourceQueryImplementation(sourceRoots, testRoots, helper, eval),	530	QuerySupport.createBinaryForSourceQueryImplementation(sourceRoots, testRoots, helper, eval),
531	});	531	});
		532	lookup = base;
532	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-web-project/Lookup"); //NOI18N	533	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-web-project/Lookup"); //NOI18N
533	}	534	}
534		535

Return to bug 146852

Lines 104-109 Link Here

(-)a/project.ant/apichanges.xml (+16 lines)
104	<!-- ACTUAL CHANGES BEGIN HERE: -->	104	<!-- ACTUAL CHANGES BEGIN HERE: -->
105		105
106	<changes>	106	<changes>
		107
		108	<change id="SourcesHelper-Project-constructor">
		109	<api name="general"/>
		110	<summary>Added <code>SourcesHelper</code> constructor accepting <code>Project</code></summary>
		111	<version major="1" minor="31"/>
		112	<date day="27" month="3" year="2009"/>
		113	<author login="tzezula"/>
		114	<compatibility addition="yes" deprecation="yes"/>
		115	<description>
		116	<p>
		117	The new constructor enables simplified control flow.
		118	</p>
		119	</description>
		120	<class package="org.netbeans.spi.project.support.ant" name="SourcesHelper"/>
		121	<issue number="146852"/>
		122	</change>
107		123
108	<change id="antbasedprojectregistration">	124	<change id="antbasedprojectregistration">
109	<api name="general"/>	125	<api name="general"/>

Lines 74-79 Link Here

(-)a/project.ant/src/org/netbeans/spi/project/support/ant/SourcesHelper.java (-9 / +32 lines)
74	import org.openide.filesystems.FileStateInvalidException;	74	import org.openide.filesystems.FileStateInvalidException;
75	import org.openide.filesystems.FileUtil;	75	import org.openide.filesystems.FileUtil;
76	import org.openide.util.ChangeSupport;	76	import org.openide.util.ChangeSupport;
		77	import org.openide.util.Parameters;
77	import org.openide.util.WeakListeners;	78	import org.openide.util.WeakListeners;
78		79
79	// XXX should perhaps be legal to call add* methods at any time (should update things)	80	// XXX should perhaps be legal to call add* methods at any time (should update things)
Lines 98-104 Link Here
98	if (val == null) {	99	if (val == null) {
99	return null;	100	return null;
100	}	101	}
101	return project.resolveFile(val);	102	return aph.resolveFile(val);
102	}	103	}
103	public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {	104	public Collection<FileObject> getIncludeRoots(boolean minimalSubfolders) {
104	File loc = getActualLocation();	105	File loc = getActualLocation();
Lines 292-298 Link Here
292	}	293	}
293	}	294	}
294		295
295	private final AntProjectHelper project;	296	private final AntProjectHelper aph;
		297	private final Project project;
296	private final PropertyEvaluator evaluator;	298	private final PropertyEvaluator evaluator;
297	private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();	299	private final List<SourceRoot> principalSourceRoots = new ArrayList<SourceRoot>();
298	private final List<Root> nonSourceRoots = new ArrayList<Root>();	300	private final List<Root> nonSourceRoots = new ArrayList<Root>();
Lines 312-322 Link Here
312	/**	314	/**
313	* Create the helper object, initially configured to recognize only sources	315	* Create the helper object, initially configured to recognize only sources
314	* contained inside the project directory.	316	* contained inside the project directory.
315	* @param project an Ant project helper	317	* @param aph an Ant project helper
316	* @param evaluator a way to evaluate Ant properties used to define source locations	318	* @param evaluator a way to evaluate Ant properties used to define source locations
		319	* @deprecated Rather use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
317	*/	320	*/
318	public SourcesHelper(AntProjectHelper project, PropertyEvaluator evaluator) {	321	@Deprecated
		322	public SourcesHelper(AntProjectHelper aph, PropertyEvaluator evaluator) {
		323	this.project = null;
		324	this.aph = aph;
		325	this.evaluator = evaluator;
		326	}
		327
		328	/**
		329	* Create the helper object, initially configured to recognize only sources
		330	* contained inside the project directory.
		331	* @param project the project object (need not yet be registered in {@link ProjectManager})
		332	* @param aph an Ant project helper
		333	* @param evaluator a way to evaluate Ant properties used to define source locations
		334	* @since org.netbeans.modules.project.ant/1 1.31
		335	*/
		336	public SourcesHelper(Project project, AntProjectHelper aph, PropertyEvaluator evaluator) {
		337	Parameters.notNull("project", project);
319	this.project = project;	338	this.project = project;
		339	this.aph = aph;
320	this.evaluator = evaluator;	340	this.evaluator = evaluator;
321	}	341	}
322		342
Lines 470-476 Link Here
470	}	490	}
471		491
472	private Project getProject() {	492	private Project getProject() {
473	return AntBasedProjectFactorySingleton.getProjectFor(project);	493	return project != null ? project : AntBasedProjectFactorySingleton.getProjectFor(aph);
474	}	494	}
475		495
476	/**	496	/**
Lines 504-514 Link Here
504	* {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.	524	* {@link FileOwnerQuery#EXTERNAL_ALGORITHM_TRANSIENT}.
505	* </p>	525	* </p>
506	* <p>	526	* <p>
507	* You may <em>not</em> call this method inside the project's constructor, as	527	* If you used the old constructor form
508	* it requires the actual project to exist and be registered in {@link ProjectManager}.	528	* {@link #SourcesHelper(AntProjectHelper, PropertyEvaluator)}
509	* Typically you would use {@link org.openide.util.Mutex#postWriteRequest} to run it	529	* then you may <em>not</em> call this method inside the project's constructor, as
		530	* it requires the actual project to exist and be registered in {@link ProjectManager};
		531	* in this case you could still use {@link org.openide.util.Mutex#postWriteRequest} to run it
510	* later, if you were creating the helper in your constructor, since the project construction	532	* later, if you were creating the helper in your constructor, since the project construction
511	* normally occurs in read access.	533	* normally occurs in read access.
		534	* Better to use {@link #SourcesHelper(Project, AntProjectHelper, PropertyEvaluator)}.
512	* </p>	535	* </p>
513	* @param algorithm an external root registration algorithm as per	536	* @param algorithm an external root registration algorithm as per
514	* {@link FileOwnerQuery#markExternalOwner}	537	* {@link FileOwnerQuery#markExternalOwner}
Lines 584-590 Link Here
584	allRoots.addAll(nonSourceRoots);	607	allRoots.addAll(nonSourceRoots);
585	allRoots.addAll(ownedFiles);	608	allRoots.addAll(ownedFiles);
586	Project p = getProject();	609	Project p = getProject();
587	FileObject pdir = project.getProjectDirectory();	610	FileObject pdir = aph.getProjectDirectory();
588	// First time: register roots and add to lastRegisteredRoots.	611	// First time: register roots and add to lastRegisteredRoots.
589	// Subsequent times: add to newRootsToRegister and maybe add them later.	612	// Subsequent times: add to newRootsToRegister and maybe add them later.
590	if (lastRegisteredRoots == null) {	613	if (lastRegisteredRoots == null) {

Lines 40-61 Link Here

(-)a/projectimport.eclipse.core/src/org/netbeans/modules/projectimport/eclipse/core/spi/UpgradableProjectLookupProvider.java (-4 / +15 lines)
40	package org.netbeans.modules.projectimport.eclipse.core.spi;	40	package org.netbeans.modules.projectimport.eclipse.core.spi;
41		41
42	import org.netbeans.api.project.Project;	42	import org.netbeans.api.project.Project;
		43	import org.netbeans.api.project.ProjectUtils;
43	import org.netbeans.modules.projectimport.eclipse.core.ProjectOpenHookImpl;	44	import org.netbeans.modules.projectimport.eclipse.core.ProjectOpenHookImpl;
44	import org.netbeans.modules.projectimport.eclipse.core.UpgradableProject;	45	import org.netbeans.modules.projectimport.eclipse.core.UpgradableProject;
45	import org.netbeans.spi.project.LookupProvider;	46	import org.netbeans.spi.project.LookupProvider;
46	import org.openide.util.Lookup;	47	import org.openide.util.Lookup;
47	import org.openide.util.lookup.Lookups;	48	import org.openide.util.lookup.Lookups;
48		49
49	// registered separately in j2se and web modules, but could use @LookupProvider.Registration	50	// registered separately in j2se and web modules, otherwise could use @LookupProvider.Registration
50	final public class UpgradableProjectLookupProvider implements LookupProvider {	51	final public class UpgradableProjectLookupProvider implements LookupProvider {
51		52
52	public Lookup createAdditionalLookup(Lookup baseContext) {	53	public Lookup createAdditionalLookup(Lookup baseContext) {
53	Project p = baseContext.lookup(Project.class);	54	Project p = baseContext.lookup(Project.class);
54	assert p != null;	55	assert p != null;
55	UpgradableProject up = new UpgradableProject(p);	56	if (ProjectUtils.getPreferences(p, UpgradableProjectLookupProvider.class, true).
		57	get("project", null) == null) { // NOI18N
		58	// Shortcut, the normal case:
		59	return Lookup.EMPTY;
		60	} else {
		61	// Keep as separate method to try to delay class initialization:
		62	return upgradeLookup(p);
		63	}
		64	}
		65
		66	private static Lookup upgradeLookup(Project p) {
56	return Lookups.fixed(	67	return Lookups.fixed(
57	up,	68	new UpgradableProject(p),
58	new ProjectOpenHookImpl(p, up));	69	new ProjectOpenHookImpl());
59	}	70	}
60		71
61	}	72	}

Lines 46-52 Link Here

(-)a/projectimport.eclipse.core/test/unit/src/org/netbeans/modules/projectimport/eclipse/core/spi/ProjectFactorySupportTest.java (-33 lines)
46	import java.util.Collections;	46	import java.util.Collections;
47	import java.util.List;	47	import java.util.List;
48	import org.netbeans.api.java.platform.JavaPlatform;	48	import org.netbeans.api.java.platform.JavaPlatform;
49	import org.netbeans.api.project.FileOwnerQuery;
50	import org.netbeans.api.project.Project;	49	import org.netbeans.api.project.Project;
51	import org.netbeans.api.project.ProjectManager;	50	import org.netbeans.api.project.ProjectManager;
52	import org.netbeans.api.project.ProjectUtils;	51	import org.netbeans.api.project.ProjectUtils;
Lines 225-238 Link Here
225	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	224	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
226	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	225	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
227	List<String> importProblems = new ArrayList<String>();	226	List<String> importProblems = new ArrayList<String>();
228
229	//
230	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
231	//
232	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
233	// it is too late and above problem happens. Mark external source roots explicitly here:
234	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
235
236	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	227	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
237	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	228	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
238	assertEquals(	229	assertEquals(
Lines 262-275 Link Here
262	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	253	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
263	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	254	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
264	List<String> importProblems = new ArrayList<String>();	255	List<String> importProblems = new ArrayList<String>();
265
266	//
267	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
268	//
269	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
270	// it is too late and above problem happens. Mark external source roots explicitly here:
271	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
272
273	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	256	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
274	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	257	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
275	assertEquals(	258	assertEquals(
Lines 355-368 Link Here
355	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);	338	model.getEclipseTestSourceRootsAsFileArray(), null, null, null);
356	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());	339	J2SEProject p = (J2SEProject)ProjectManager.getDefault().findProject(helper.getProjectDirectory());
357	List<String> importProblems = new ArrayList<String>();	340	List<String> importProblems = new ArrayList<String>();
358
359	//
360	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
361	//
362	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
363	// it is too late and above problem happens. Mark external source roots explicitly here:
364	FileOwnerQuery.markExternalOwner(model.getEclipseSourceRootsAsFileArray()[0].toURI(), p, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
365
366	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);	341	ProjectFactorySupport.updateProjectClassPath(helper, p.getReferenceHelper(), model, importProblems);
367	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);	342	EditableProperties ep = helper.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
368	// required project "JavaLibrary1" is not available and therefore should not be	343	// required project "JavaLibrary1" is not available and therefore should not be
Lines 411-424 Link Here
411	mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);	386	mdl_d.getEclipseTestSourceRootsAsFileArray(), null, null, null);
412	List<String> problems = new ArrayList<String>();	387	List<String> problems = new ArrayList<String>();
413	J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());	388	J2SEProject j2seprj_d = (J2SEProject) ProjectManager.getDefault().findProject(aph_d.getProjectDirectory());
414
415	//
416	// NB-Core-Build #1293: "No project found to correspond to .../spcp/eclipse/src" from ProjectClassPathModifier.findExtensible
417	//
418	// Looks like J2SEProject registers its external source roots asynchronously and sometimes
419	// it is too late and above problem happens. Mark external source roots explicitly here:
420	FileOwnerQuery.markExternalOwner(mdl_d.getEclipseSourceRootsAsFileArray()[0].toURI(), j2seprj_d, FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
421
422	ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);	389	ProjectFactorySupport.updateProjectClassPath(aph_d, j2seprj_d.getReferenceHelper(), mdl_d, problems);
423	assertEquals(Collections.emptyList(), problems);	390	assertEquals(Collections.emptyList(), problems);
424	assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));	391	assertEquals("${reference.c.jar}:${reference.b.jar}", aph_d.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH).get("javac.classpath"));

Lines 156-162 Link Here

(-)a/java.j2seproject/src/org/netbeans/modules/java/j2seproject/J2SEProject.java (-2 / +3 lines)
156	private final PropertyEvaluator eval;	156	private final PropertyEvaluator eval;
157	private final ReferenceHelper refHelper;	157	private final ReferenceHelper refHelper;
158	private final GeneratedFilesHelper genFilesHelper;	158	private final GeneratedFilesHelper genFilesHelper;
159	private final Lookup lookup;	159	private Lookup lookup;
160	private final UpdateHelper updateHelper;	160	private final UpdateHelper updateHelper;
161	private MainClassUpdater mainClassUpdater;	161	private MainClassUpdater mainClassUpdater;
162	private SourceRoots sourceRoots;	162	private SourceRoots sourceRoots;
Lines 313-319 Link Here
313	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),	313	UILookupMergerSupport.createProjectOpenHookMerger(new ProjectOpenedHookImpl()),
314	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),	314	QuerySupport.createUnitTestForSourceQuery(getSourceRoots(), getTestSourceRoots()),
315	QuerySupport.createSourceLevelQuery(evaluator()),	315	QuerySupport.createSourceLevelQuery(evaluator()),
316	new J2SESources (this.helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	316	new J2SESources(this, helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
317	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),	317	QuerySupport.createSharabilityQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()),
318	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),	318	new CoSAwareFileBuiltQueryImpl(QuerySupport.createFileBuiltQuery(helper, evaluator(), getSourceRoots(), getTestSourceRoots()), this),
319	new RecommendedTemplatesImpl (this.updateHelper),	319	new RecommendedTemplatesImpl (this.updateHelper),
Lines 335-340 Link Here
335	LookupMergerSupport.createJFBLookupMerger(),	335	LookupMergerSupport.createJFBLookupMerger(),
336	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata	336	QuerySupport.createBinaryForSourceQueryImplementation(this.sourceRoots, this.testRoots, this.helper, this.eval) //Does not use APH to get/put properties/cfgdata
337	);	337	);
		338	lookup = base; // in case LookupProvider's call Project.getLookup
338	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N	339	return LookupProviderSupport.createCompositeLookup(base, "Projects/org-netbeans-modules-java-j2seproject/Lookup"); //NOI18N
339	}	340	}
340		341