compiler/src/main/java/org/apache/royale/compiler/internal/projects/ASProject.java - royale-compiler - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package org.apache.royale.compiler.internal.projects;

 import java.io.File;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.apache.royale.compiler.asdoc.IASDocBundleDelegate;
 import org.apache.royale.compiler.common.IFileSpecificationGetter;
 import org.apache.royale.compiler.definitions.IDefinition;
 import org.apache.royale.compiler.internal.projects.SourcePathManager.QNameFile;
 import org.apache.royale.compiler.internal.units.CompilationUnitBase;
 import org.apache.royale.compiler.internal.units.InvisibleCompilationUnit;
 import org.apache.royale.compiler.internal.units.SourceCompilationUnitFactory;
 import org.apache.royale.compiler.internal.workspaces.Workspace;
 import org.apache.royale.compiler.problems.ICompilerProblem;
 import org.apache.royale.compiler.projects.IASProject;
 import org.apache.royale.compiler.units.ICompilationUnit;
 import org.apache.royale.compiler.units.IInvisibleCompilationUnit;
 import org.apache.royale.swc.ISWC;
 import org.apache.royale.swc.ISWCFileEntry;

 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;

 /**
  * Implementation base class to implement functionality common to all
  * IASProject implementations. DefinitionPromises ( aka
  * "provisional definitions" ) are added to the project scope in this class.
  */
 public abstract class ASProject extends CompilerProject implements IASProject
 {

     /**
      * Constructor
      *
      * @param workspace The Workspace in which this project lives.
      * @param useAS3 Indicate whether or not the AS3 namespace should
      * be opened in all compilation units in the project.
      */
     public ASProject(Workspace workspace, boolean useAS3)
     {
         this(workspace, useAS3, IASDocBundleDelegate.NIL_DELEGATE);
     }

     public ASProject(Workspace workspace, boolean useAS3, IASDocBundleDelegate asDocBundleDelegate)
     {
         super(workspace, useAS3);
         sourcePathManager = new SourcePathManager(this);
         sourceListManager = new SourceListManager(this, sourcePathManager);
         sourceCompilationUnitFactory = new SourceCompilationUnitFactory(this);
         sourceCompilationUnitFactory.addHandler(ASSourceFileHandler.INSTANCE);
         sourceCompilationUnitFactory.addHandler(FXGSourceFileHandler.INSTANCE);
         libraryPathManager = new LibraryPathManager(this);
         projectDependencies = new HashMap<IASProject, String>();
         dependingProjects = new HashSet<IASProject>();
         this.asDocBundleDelegate = asDocBundleDelegate;
     }

     private final SourceListManager sourceListManager;
     private final SourcePathManager sourcePathManager;
     private final SourceCompilationUnitFactory sourceCompilationUnitFactory;
     private final LibraryPathManager libraryPathManager;
     private final Map<IASProject, String> projectDependencies;
     private final Set<IASProject> dependingProjects;
     private final IASDocBundleDelegate asDocBundleDelegate;
     private int compatibilityVersionMajor;
     private int compatibilityVersionMinor;
     private int compatibilityVersionRevision;

     @Override
     public List<ISWC> getLibraries()
     {
         final ImmutableList<ISWC> result = new ImmutableList.Builder<ISWC>()
         .addAll(libraryPathManager.getLibrarySWCs())
         .build();

         return result;
     }

     @Override
     public void attachInternalLibrarySourcePath(File library, File sourceDir)
     {
         libraryPathManager.setLibrarySourcePath(library, sourceDir);
     }

     @Override
     public void attachExternalLibrarySourcePath(File library, File sourceDir)
     {
         // TODO: rename this and attachInternalLibraySourcePath to be
         // just attachLibrarySourcePath.
         libraryPathManager.setLibrarySourcePath(library, sourceDir);
     }

     @Override
     public String getAttachedSourceDirectory(String libraryFilename)
     {
         String result = libraryPathManager.getAttachedSourceDirectory(libraryFilename);
         return result;
     }

     @Override
     public void setSourcePath(List<File> paths)
     {
         sourcePathManager.setSourcePath(paths.toArray(new File[paths.size()]));
     }

     @Override
     public List<File> getSourcePath()
     {
         return sourcePathManager.getSourcePath();
     }

     /**
      * Adds a file to the project if that file is on the project's
      * source path.
      * @param f The file to be added.
      * @return true if any new {@link ICompilationUnit}'s were created
      * as a result of this operation, false otherwise.
      */
     public boolean addSourcePathFile(File f)
     {
         return sourcePathManager.addFile(f);
     }

     /**
      * Test if a file is on the source path or not.
      *
      * @param f The file to test. May not be null.
      * @return true if the file is on the source path, false otherwise.
      */
     public boolean isFileOnSourcePath(File f)
     {
         return sourcePathManager.isFileOnSourcePath(f);
     }

     @Override
     public void setIncludeSources(File files[]) throws InterruptedException
     {
         sourceListManager.setSourceList(files);
     }

     @Override
     public void addIncludeSourceFile(File file) throws InterruptedException
     {
         addIncludeSourceFile(file, false);
     }

     @Override
     public void addIncludeSourceFile(File file, boolean overrideSourcePath) throws InterruptedException
     {
         sourceListManager.addSource(file, overrideSourcePath);
     }

     @Override
     public void removeIncludeSourceFile(File file) throws InterruptedException
     {
         sourceListManager.removeSource(file);
     }

     /**
      * Removes a source file to the project, removing any references in the various
      * managers - SourcePathManager, SourceListManager etc
      *
      * @see #addIncludeSourceFile(File)
      * @param f File to remove.
      */
     public void removeSourceFile(File f)
     {
         try
         {
             // TODO: this is mostly a place holder for now.  Need
             // to go through and cleanup the whole removal flow

             // note that the assumption is that these functions
             // will fail gracefully if the file is not included
             // in the various managers

             // remove any reference to this file in the
             // source list manager
             sourceListManager.removeSource(f);

             // remove any reference to this file in the
             // source path manager
             sourcePathManager.removeFile(f);

         }
         catch (InterruptedException e)
         {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     public SourceCompilationUnitFactory getSourceCompilationUnitFactory()
     {
         return sourceCompilationUnitFactory;
     }

     /**
      * Called by {@link SourcePathManager} or {@link LibraryPathManager} when the source
      * or library path change.
      * @param toRemove {@link ICompilationUnit}'s to remove from the project.
      * @param toAdd {@link ICompilationUnit}'s to add to the project.
      */
     void updateCompilationUnitsForPathChange(Collection<ICompilationUnit> toRemove, Collection<ICompilationUnit> toAdd)
     {
         assert toRemove != null;
         assert toAdd != null;
         removeCompilationUnits(toRemove);
         addCompilationUnits(toAdd);

         for (ICompilationUnit unit : toAdd)
         {
             for (IDefinition definitionPromise : unit.getDefinitionPromises())
             {
                 getScope().addDefinition(definitionPromise);
             }
         }
     }

     @Override
     public Set<IASProject> getDependingProjects()
     {
         return dependingProjects;
     }

     @Override
     public void addProjectDependeny(IASProject project, String swcFilename)
     {
         assert (project instanceof ASProject) : "project dependency must be of type ASProject";
         ((ASProject)project).dependingProjects.add(this);
         projectDependencies.put(project, swcFilename);
     }

     @Override
     public void removeProjectDependeny(IASProject project)
     {
         assert (project instanceof ASProject) : "project dependency must be of type ASProject";
         ((ASProject)project).dependingProjects.remove(this);
         projectDependencies.remove(project);
     }

     @Override
     public void setDependencies(Map<IASProject, String> newIProjectsDependencies)
     {
         Set<IASProject> newProjectDependencies = ImmutableSet.<IASProject> copyOf(newIProjectsDependencies.keySet());
         Set<IASProject> dependenciesToRemove = ImmutableSet.<IASProject> copyOf(Sets.difference(projectDependencies.keySet(), newProjectDependencies));
         Set<IASProject> dependenciesToAdd = ImmutableSet.<IASProject> copyOf(Sets.difference(newProjectDependencies, projectDependencies.keySet()));

         for (IASProject projectDependency : dependenciesToRemove)
         {
             removeProjectDependeny(projectDependency);
         }

         for (IASProject projectDependency : dependenciesToAdd)
         {
             String swcFilename = newIProjectsDependencies.get(projectDependency);
             addProjectDependeny(projectDependency, swcFilename);
         }
     }

     /**
      * Called by {@link SourceListManager} when the include sources list is changed.
      * @param toRemove {@link ICompilationUnit}'s to remove from the project.
      * @param toAdd {@link ICompilationUnit}'s to add to the project.
      */
     void sourceListChange(Collection<ICompilationUnit> toRemove, Collection<ICompilationUnit> toAdd) throws InterruptedException
     {
         // passing empty lists to removeCompilationUnits
         // and addCompilationUnitsAndUpdateDefinitions *is* harmless
         // but avoiding the call to sourcePathManager.sourceListChanged
         // will prevent us from enumerating a bunch of directories on disk
         if ((!toRemove.isEmpty()) || (!toAdd.isEmpty()))
         {
             removeCompilationUnits(toRemove);
             addCompilationUnitsAndUpdateDefinitions(toAdd);
         }
     }

     @Override
     public void collectProblems(Collection<ICompilerProblem> problems)
     {
         sourcePathManager.collectProblems(problems);
         sourceListManager.collectProblems(problems);
         libraryPathManager.collectProblems(problems);
         collectConfigProblems(problems);
     }

     /**
      * Finds all the {@link ICompilationUnit}'s in this project whose root source file is the specified file.
      */
     public void collectionCompilationUnitsForRootSourceFile(File rootSourceFile, Collection<ICompilationUnit> units)
     {
         sourcePathManager.collectionCompilationUnitsForRootSourceFile(rootSourceFile, units);
         sourceListManager.collectionCompilationUnitsForRootSourceFile(rootSourceFile, units);
     }

     public boolean hasCompilationUnitForRootSourceFile(File rootSourceFile)
     {
         return sourcePathManager.hasCompilationUnitsForRootSourceFile(rootSourceFile) ||
                sourceListManager.hasCompilationUnitsForRootSourceFile(rootSourceFile);
     }

     @Override
     public boolean invalidateLibraries(Collection<File> swcFiles)
     {
         return libraryPathManager.invalidate(swcFiles);
     }

     @Override
     public void invalidateLibrary(ISWC swc)
     {
         libraryPathManager.invalidate(swc);
     }

     @Override
     public boolean handleAddedFile(File addedFile)
     {
         return addSourcePathFile(addedFile);
     }

     @Override
     public String getSourceFileFromSourcePath(String file)
     {
         return sourcePathManager.getSourceFileFromSourcePath(file);
     }

     /**
      * Iterate through the library path list looking for the specified file.
      * @param file to look for
      * @return ISWCFileEntry to the file, or null if file not found
      */
     public ISWCFileEntry getSourceFileFromLibraryPath(String file)
     {
         return libraryPathManager.getFileEntryFromLibraryPath(file);
     }

     public IASDocBundleDelegate getASDocBundleDelegate()
     {
         return asDocBundleDelegate;
     }

     @Override
     public void setLibraries(List<File> libraries)
     {
         assert libraries != null : "Libraries may not be null";

         libraryPathManager.setLibraryPath(libraries.toArray(new File[libraries.size()]));
     }

     /**
      * Sets the SDK compatibility version. For this release, the only valid value is 2.0.1.
      *
      * @param major The major version. For this release, this value must be 2.
      * @param minor The minor version. For this release, this value must be 0.
      * @param revision For this release, this value must be 1.
      */
     public void setCompatibilityVersion(int major, int minor, int revision)
     {
         compatibilityVersionMajor = major;
         compatibilityVersionMinor = minor;
         compatibilityVersionRevision = revision;
         clean();
     }

     @Override
     public Integer getCompatibilityVersion()
     {
         int compatibilityVersion = (compatibilityVersionMajor << 24) + (compatibilityVersionMinor << 16) +
                                    compatibilityVersionRevision;

         return compatibilityVersion != 0 ? compatibilityVersion : null;
     }

     @Override
     public String getCompatibilityVersionString()
     {
         int sum = compatibilityVersionMajor + compatibilityVersionMinor + compatibilityVersionRevision;

         if (sum == 0)
             return null;

         return compatibilityVersionMajor + "." +
                compatibilityVersionMinor + "." +
                compatibilityVersionRevision;
     }

     @Override
     public IInvisibleCompilationUnit createInvisibleCompilationUnit(String rootSourceFile, IFileSpecificationGetter fileSpecGetter)
     {
         QNameFile qNameFile = sourcePathManager.computeQNameForFilename(rootSourceFile);
         if (qNameFile == null)
             return null;

         CompilationUnitBase invisibleCUDelegate = createInvisibleCompilationUnit(qNameFile);
         if (invisibleCUDelegate == null)
             return null;

         return new InvisibleCompilationUnit(invisibleCUDelegate, fileSpecGetter);
     }

     @Override
     public IInvisibleCompilationUnit createInvisibleCompilationUnit(String rootSourceFile, IFileSpecificationGetter fileSpecGetter, String qName)
     {
         QNameFile qNameFile = new QNameFile(qName, new File(rootSourceFile), null, 0);
         CompilationUnitBase invisibleCUDelegate = createInvisibleCompilationUnit(qNameFile);
         if (invisibleCUDelegate == null)
             return null;

         return new InvisibleCompilationUnit(invisibleCUDelegate, fileSpecGetter);
     }

     /**
      * Create's a new {@link CompilationUnitBase} that is marked as being a
      * delegate for an {@link InvisibleCompilationUnit}.
      *
      * @param qNameFile The qNameFile of the new {@link InvisibleCompilationUnit}.
      * @return A new {@link CompilationUnitBase} that is marked as being a
      * delegate for an {@link InvisibleCompilationUnit} or null if the specified
      * file name is not on the source path.
      */
     private CompilationUnitBase createInvisibleCompilationUnit(QNameFile qNameFile)
     {
         SourceCompilationUnitFactory compilationUnitFactory = getSourceCompilationUnitFactory();
         if (!compilationUnitFactory.canCreateCompilationUnit(qNameFile.file))
             return null;

         CompilationUnitBase newCU = (CompilationUnitBase)getSourceCompilationUnitFactory().createCompilationUnit(
                 qNameFile.file, DefinitionPriority.BasePriority.SOURCE_PATH, 0, qNameFile.qName, qNameFile.locale);
         assert newCU != null : "canCreateCompilationUnit should have returned false if createCompilationUnit returns null!";
         addCompilationUnit(newCU);
         return newCU;
     }

     @Override
     public boolean isAssetEmbeddingSupported()
     {
         return true;
     }

     @Override
     public boolean isSupportedSourceFileType(String fileExtension)
     {
         return sourceCompilationUnitFactory.canCreateCompilationUnitForFileType(fileExtension);
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package org.apache.royale.compiler.internal.projects;

	import java.io.File;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.apache.royale.compiler.asdoc.IASDocBundleDelegate;
	import org.apache.royale.compiler.common.IFileSpecificationGetter;
	import org.apache.royale.compiler.definitions.IDefinition;
	import org.apache.royale.compiler.internal.projects.SourcePathManager.QNameFile;
	import org.apache.royale.compiler.internal.units.CompilationUnitBase;
	import org.apache.royale.compiler.internal.units.InvisibleCompilationUnit;
	import org.apache.royale.compiler.internal.units.SourceCompilationUnitFactory;
	import org.apache.royale.compiler.internal.workspaces.Workspace;
	import org.apache.royale.compiler.problems.ICompilerProblem;
	import org.apache.royale.compiler.projects.IASProject;
	import org.apache.royale.compiler.units.ICompilationUnit;
	import org.apache.royale.compiler.units.IInvisibleCompilationUnit;
	import org.apache.royale.swc.ISWC;
	import org.apache.royale.swc.ISWCFileEntry;

	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Sets;

	/**
	* Implementation base class to implement functionality common to all
	* IASProject implementations. DefinitionPromises ( aka
	* "provisional definitions" ) are added to the project scope in this class.
	*/
	public abstract class ASProject extends CompilerProject implements IASProject
	{

	/**
	* Constructor
	*
	* @param workspace The Workspace in which this project lives.
	* @param useAS3 Indicate whether or not the AS3 namespace should
	* be opened in all compilation units in the project.
	*/
	public ASProject(Workspace workspace, boolean useAS3)
	{
	this(workspace, useAS3, IASDocBundleDelegate.NIL_DELEGATE);
	}

	public ASProject(Workspace workspace, boolean useAS3, IASDocBundleDelegate asDocBundleDelegate)
	{
	super(workspace, useAS3);
	sourcePathManager = new SourcePathManager(this);
	sourceListManager = new SourceListManager(this, sourcePathManager);
	sourceCompilationUnitFactory = new SourceCompilationUnitFactory(this);
	sourceCompilationUnitFactory.addHandler(ASSourceFileHandler.INSTANCE);
	sourceCompilationUnitFactory.addHandler(FXGSourceFileHandler.INSTANCE);
	libraryPathManager = new LibraryPathManager(this);
	projectDependencies = new HashMap<IASProject, String>();
	dependingProjects = new HashSet<IASProject>();
	this.asDocBundleDelegate = asDocBundleDelegate;
	}

	private final SourceListManager sourceListManager;
	private final SourcePathManager sourcePathManager;
	private final SourceCompilationUnitFactory sourceCompilationUnitFactory;
	private final LibraryPathManager libraryPathManager;
	private final Map<IASProject, String> projectDependencies;
	private final Set<IASProject> dependingProjects;
	private final IASDocBundleDelegate asDocBundleDelegate;
	private int compatibilityVersionMajor;
	private int compatibilityVersionMinor;
	private int compatibilityVersionRevision;

	@Override
	public List<ISWC> getLibraries()
	{
	final ImmutableList<ISWC> result = new ImmutableList.Builder<ISWC>()
	.addAll(libraryPathManager.getLibrarySWCs())
	.build();

	return result;
	}

	@Override
	public void attachInternalLibrarySourcePath(File library, File sourceDir)
	{
	libraryPathManager.setLibrarySourcePath(library, sourceDir);
	}

	@Override
	public void attachExternalLibrarySourcePath(File library, File sourceDir)
	{
	// TODO: rename this and attachInternalLibraySourcePath to be
	// just attachLibrarySourcePath.
	libraryPathManager.setLibrarySourcePath(library, sourceDir);
	}

	@Override
	public String getAttachedSourceDirectory(String libraryFilename)
	{
	String result = libraryPathManager.getAttachedSourceDirectory(libraryFilename);
	return result;
	}

	@Override
	public void setSourcePath(List<File> paths)
	{
	sourcePathManager.setSourcePath(paths.toArray(new File[paths.size()]));
	}

	@Override
	public List<File> getSourcePath()
	{
	return sourcePathManager.getSourcePath();
	}

	/**
	* Adds a file to the project if that file is on the project's
	* source path.
	* @param f The file to be added.
	* @return true if any new {@link ICompilationUnit}'s were created
	* as a result of this operation, false otherwise.
	*/
	public boolean addSourcePathFile(File f)
	{
	return sourcePathManager.addFile(f);
	}

	/**
	* Test if a file is on the source path or not.
	*
	* @param f The file to test. May not be null.
	* @return true if the file is on the source path, false otherwise.
	*/
	public boolean isFileOnSourcePath(File f)
	{
	return sourcePathManager.isFileOnSourcePath(f);
	}

	@Override
	public void setIncludeSources(File files[]) throws InterruptedException
	{
	sourceListManager.setSourceList(files);
	}

	@Override
	public void addIncludeSourceFile(File file) throws InterruptedException
	{
	addIncludeSourceFile(file, false);
	}

	@Override
	public void addIncludeSourceFile(File file, boolean overrideSourcePath) throws InterruptedException
	{
	sourceListManager.addSource(file, overrideSourcePath);
	}

	@Override
	public void removeIncludeSourceFile(File file) throws InterruptedException
	{
	sourceListManager.removeSource(file);
	}

	/**
	* Removes a source file to the project, removing any references in the various
	* managers - SourcePathManager, SourceListManager etc
	*
	* @see #addIncludeSourceFile(File)
	* @param f File to remove.
	*/
	public void removeSourceFile(File f)
	{
	try
	{
	// TODO: this is mostly a place holder for now. Need
	// to go through and cleanup the whole removal flow

	// note that the assumption is that these functions
	// will fail gracefully if the file is not included
	// in the various managers

	// remove any reference to this file in the
	// source list manager
	sourceListManager.removeSource(f);

	// remove any reference to this file in the
	// source path manager
	sourcePathManager.removeFile(f);

	}
	catch (InterruptedException e)
	{
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	}

	public SourceCompilationUnitFactory getSourceCompilationUnitFactory()
	{
	return sourceCompilationUnitFactory;
	}

	/**
	* Called by {@link SourcePathManager} or {@link LibraryPathManager} when the source
	* or library path change.
	* @param toRemove {@link ICompilationUnit}'s to remove from the project.
	* @param toAdd {@link ICompilationUnit}'s to add to the project.
	*/
	void updateCompilationUnitsForPathChange(Collection<ICompilationUnit> toRemove, Collection<ICompilationUnit> toAdd)
	{
	assert toRemove != null;
	assert toAdd != null;
	removeCompilationUnits(toRemove);
	addCompilationUnits(toAdd);

	for (ICompilationUnit unit : toAdd)
	{
	for (IDefinition definitionPromise : unit.getDefinitionPromises())
	{
	getScope().addDefinition(definitionPromise);
	}
	}
	}

	@Override
	public Set<IASProject> getDependingProjects()
	{
	return dependingProjects;
	}

	@Override
	public void addProjectDependeny(IASProject project, String swcFilename)
	{
	assert (project instanceof ASProject) : "project dependency must be of type ASProject";
	((ASProject)project).dependingProjects.add(this);
	projectDependencies.put(project, swcFilename);
	}

	@Override
	public void removeProjectDependeny(IASProject project)
	{
	assert (project instanceof ASProject) : "project dependency must be of type ASProject";
	((ASProject)project).dependingProjects.remove(this);
	projectDependencies.remove(project);
	}

	@Override
	public void setDependencies(Map<IASProject, String> newIProjectsDependencies)
	{
	Set<IASProject> newProjectDependencies = ImmutableSet.<IASProject> copyOf(newIProjectsDependencies.keySet());
	Set<IASProject> dependenciesToRemove = ImmutableSet.<IASProject> copyOf(Sets.difference(projectDependencies.keySet(), newProjectDependencies));
	Set<IASProject> dependenciesToAdd = ImmutableSet.<IASProject> copyOf(Sets.difference(newProjectDependencies, projectDependencies.keySet()));

	for (IASProject projectDependency : dependenciesToRemove)
	{
	removeProjectDependeny(projectDependency);
	}

	for (IASProject projectDependency : dependenciesToAdd)
	{
	String swcFilename = newIProjectsDependencies.get(projectDependency);
	addProjectDependeny(projectDependency, swcFilename);
	}
	}

	/**
	* Called by {@link SourceListManager} when the include sources list is changed.
	* @param toRemove {@link ICompilationUnit}'s to remove from the project.
	* @param toAdd {@link ICompilationUnit}'s to add to the project.
	*/
	void sourceListChange(Collection<ICompilationUnit> toRemove, Collection<ICompilationUnit> toAdd) throws InterruptedException
	{
	// passing empty lists to removeCompilationUnits
	// and addCompilationUnitsAndUpdateDefinitions is harmless
	// but avoiding the call to sourcePathManager.sourceListChanged
	// will prevent us from enumerating a bunch of directories on disk
	if ((!toRemove.isEmpty()) \|\| (!toAdd.isEmpty()))
	{
	removeCompilationUnits(toRemove);
	addCompilationUnitsAndUpdateDefinitions(toAdd);
	}
	}

	@Override
	public void collectProblems(Collection<ICompilerProblem> problems)
	{
	sourcePathManager.collectProblems(problems);
	sourceListManager.collectProblems(problems);
	libraryPathManager.collectProblems(problems);
	collectConfigProblems(problems);
	}

	/**
	* Finds all the {@link ICompilationUnit}'s in this project whose root source file is the specified file.
	*/
	public void collectionCompilationUnitsForRootSourceFile(File rootSourceFile, Collection<ICompilationUnit> units)
	{
	sourcePathManager.collectionCompilationUnitsForRootSourceFile(rootSourceFile, units);
	sourceListManager.collectionCompilationUnitsForRootSourceFile(rootSourceFile, units);
	}

	public boolean hasCompilationUnitForRootSourceFile(File rootSourceFile)
	{
	return sourcePathManager.hasCompilationUnitsForRootSourceFile(rootSourceFile) \|\|
	sourceListManager.hasCompilationUnitsForRootSourceFile(rootSourceFile);
	}

	@Override
	public boolean invalidateLibraries(Collection<File> swcFiles)
	{
	return libraryPathManager.invalidate(swcFiles);
	}

	@Override
	public void invalidateLibrary(ISWC swc)
	{
	libraryPathManager.invalidate(swc);
	}

	@Override
	public boolean handleAddedFile(File addedFile)
	{
	return addSourcePathFile(addedFile);
	}

	@Override
	public String getSourceFileFromSourcePath(String file)
	{
	return sourcePathManager.getSourceFileFromSourcePath(file);
	}

	/**
	* Iterate through the library path list looking for the specified file.
	* @param file to look for
	* @return ISWCFileEntry to the file, or null if file not found
	*/
	public ISWCFileEntry getSourceFileFromLibraryPath(String file)
	{
	return libraryPathManager.getFileEntryFromLibraryPath(file);
	}

	public IASDocBundleDelegate getASDocBundleDelegate()
	{
	return asDocBundleDelegate;
	}

	@Override
	public void setLibraries(List<File> libraries)
	{
	assert libraries != null : "Libraries may not be null";

	libraryPathManager.setLibraryPath(libraries.toArray(new File[libraries.size()]));
	}

	/**
	* Sets the SDK compatibility version. For this release, the only valid value is 2.0.1.
	*
	* @param major The major version. For this release, this value must be 2.
	* @param minor The minor version. For this release, this value must be 0.
	* @param revision For this release, this value must be 1.
	*/
	public void setCompatibilityVersion(int major, int minor, int revision)
	{
	compatibilityVersionMajor = major;
	compatibilityVersionMinor = minor;
	compatibilityVersionRevision = revision;
	clean();
	}

	@Override
	public Integer getCompatibilityVersion()
	{
	int compatibilityVersion = (compatibilityVersionMajor << 24) + (compatibilityVersionMinor << 16) +
	compatibilityVersionRevision;

	return compatibilityVersion != 0 ? compatibilityVersion : null;
	}

	@Override
	public String getCompatibilityVersionString()
	{
	int sum = compatibilityVersionMajor + compatibilityVersionMinor + compatibilityVersionRevision;

	if (sum == 0)
	return null;

	return compatibilityVersionMajor + "." +
	compatibilityVersionMinor + "." +
	compatibilityVersionRevision;
	}

	@Override
	public IInvisibleCompilationUnit createInvisibleCompilationUnit(String rootSourceFile, IFileSpecificationGetter fileSpecGetter)
	{
	QNameFile qNameFile = sourcePathManager.computeQNameForFilename(rootSourceFile);
	if (qNameFile == null)
	return null;

	CompilationUnitBase invisibleCUDelegate = createInvisibleCompilationUnit(qNameFile);
	if (invisibleCUDelegate == null)
	return null;

	return new InvisibleCompilationUnit(invisibleCUDelegate, fileSpecGetter);
	}

	@Override
	public IInvisibleCompilationUnit createInvisibleCompilationUnit(String rootSourceFile, IFileSpecificationGetter fileSpecGetter, String qName)
	{
	QNameFile qNameFile = new QNameFile(qName, new File(rootSourceFile), null, 0);
	CompilationUnitBase invisibleCUDelegate = createInvisibleCompilationUnit(qNameFile);
	if (invisibleCUDelegate == null)
	return null;

	return new InvisibleCompilationUnit(invisibleCUDelegate, fileSpecGetter);
	}

	/**
	* Create's a new {@link CompilationUnitBase} that is marked as being a
	* delegate for an {@link InvisibleCompilationUnit}.
	*
	* @param qNameFile The qNameFile of the new {@link InvisibleCompilationUnit}.
	* @return A new {@link CompilationUnitBase} that is marked as being a
	* delegate for an {@link InvisibleCompilationUnit} or null if the specified
	* file name is not on the source path.
	*/
	private CompilationUnitBase createInvisibleCompilationUnit(QNameFile qNameFile)
	{
	SourceCompilationUnitFactory compilationUnitFactory = getSourceCompilationUnitFactory();
	if (!compilationUnitFactory.canCreateCompilationUnit(qNameFile.file))
	return null;

	CompilationUnitBase newCU = (CompilationUnitBase)getSourceCompilationUnitFactory().createCompilationUnit(
	qNameFile.file, DefinitionPriority.BasePriority.SOURCE_PATH, 0, qNameFile.qName, qNameFile.locale);
	assert newCU != null : "canCreateCompilationUnit should have returned false if createCompilationUnit returns null!";
	addCompilationUnit(newCU);
	return newCU;
	}

	@Override
	public boolean isAssetEmbeddingSupported()
	{
	return true;
	}

	@Override
	public boolean isSupportedSourceFileType(String fileExtension)
	{
	return sourceCompilationUnitFactory.canCreateCompilationUnitForFileType(fileExtension);
	}
	}