CompilerProject (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- org.apache.flex.compiler.internal.projects.CompilerProject

All Implemented Interfaces:

ICompilerProject

Direct Known Subclasses:

ASCProject, ASProject
```
public abstract class CompilerProject
extends Object
implements ICompilerProject
```
Abstract class used to share implementation of some ICompilerProject methods across multiple concrete implementation classes.

Field Summary

Fields
Modifier and Type	Field and Description
`protected DependencyGraph`	`dependencyGraph` Dependency graph is used to keep track of which `ICompilationUnit` 's are in this project.
`protected Collection<ICompilerProblem>`	`problems`
`protected Set<Target>`	`targets`

Constructor Summary

Constructors
Constructor and Description

CompilerProject(Workspace workspace, boolean useAS3)

Constructors
Constructor and Description
`CompilerProject(Workspace workspace, boolean useAS3)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addCompilationUnit(ICompilationUnit unit)` Add a `ICompilationUnit` to the project.
`void`	`addCompilationUnits(Collection<ICompilationUnit> units)` Add compilation units to the project.
`void`	`addCompilationUnitsAndUpdateDefinitions(Collection<ICompilationUnit> compilationUnits)` Adds compilation units to the project and updates the public and private definitions.
`void`	`addConfigVariable(String namespace, String expression)` Sets project config variable for use on this project
`void`	`addConfigVariables(Map<String,String> map)` Sets project config variables for use on this project
`void`	`addDependency(ICompilationUnit from, ICompilationUnit to, DependencyType dt)` Adds an anonymous dependency from one `ICompilationUnit` to another `ICompilationUnit`.
`void`	`addDependency(ICompilationUnit from, ICompilationUnit to, DependencyTypeSet dt, String qname)` Adds a dependency from one `ICompilationUnit` to another `ICompilationUnit`.
`void`	`addDependency(ICompilationUnit from, ICompilationUnit to, DependencyType dt, String qname)` Adds a dependency from one `ICompilationUnit` to another `ICompilationUnit`.
`void`	`addEmbedCompilationUnit(EmbedCompilationUnit unit)`
`void`	`addGlobalUsedNamespacesToNamespaceSet(Set<INamespaceDefinition> nsSet)`
`void`	`addToASTCache(IASNode ast)` Add AST to cache.
`void`	`addUnfoundDefinitionDependency(String definitionBaseName, ICompilationUnit compilationUnit)`
`void`	`addUnfoundReferencedSourceFileDependency(String sourceFilename, ICompilationUnit compilationUnit)` Notify project that a compilation unit could not find a referenced file.
`void`	`clean()` Removes all data created during a compile
`void`	`clearScopeCacheForCompilationUnit(ICompilationUnit compilationUnit)` Clears all the `ASScopeCache`s associated with the specified `ICompilationUnit` and removes all the `IASScope`s build by the `ICompilationUnit` from the list of scopes associated with the `ICompilationUnit`.
`protected void`	`collectConfigProblems(Collection<ICompilerProblem> problems)` Gets the project level `ICompilerProblem`'s that come from parsing the config options, from the command line, or a configuration file
`abstract void`	`collectProblems(Collection<ICompilerProblem> problems)` Gets project level `ICompilerProblem`'s target are not specific to any one target created by the project.
`ISWFTarget`	`createSWFTarget(ITargetSettings targetSettings, ITargetProgressMonitor progressMonitor)` Create a SWF target
`void`	`delete()` Called before a project is deleted.
`IDefinition`	`doubleCheckAmbiguousDefinition(ASScope scope, String name, IDefinition def1, IDefinition def2)` Override this to disambiguate between two ambiguous definitinos
`String`	`getActualPackageName(String packageName)` Override this to permit package aliasing on imports and elsewhere
`ITypeDefinition`	`getBuiltinType(IASLanguageConstants.BuiltinType type)` Helper method to get some of the built-in types (*, String, Number, etc).
`ASScopeCache`	`getCacheForScope(ASScope scope)` Get the cache for a particular scope
`EmbedCompilationUnit`	`getCompilationUnit(EmbedData data)` Return the compilation unit related this EmbedData, or it's equivalent.
`Collection<ICompilationUnit>`	`getCompilationUnits()`
`Collection<ICompilationUnit>`	`getCompilationUnits(String filename)` Get all compilation units from the filename
`Set<ICompilationUnit>`	`getDependencies(ICompilationUnit cu)` Gets the set of dependencies referenced by the specified `ICompilationUnit`. in the absence of wierd things like defaults/theme css, this is just the set of `ICompilationUnit`'s that define definitions directly referenced by the specified `ICompilationUnit`.
`Set<ICompilationUnit>`	`getDependenciesOnDefinition(String definitionBaseName)`
`Set<ICompilationUnit>`	`getDependenciesOnUnfoundDefinition(String definitionBaseName)`
`Set<ICompilationUnit>`	`getDependenciesOnUnfoundReferencedSourceFile(String sourceFilename)` gets the set of all compilation units that have an unsatisfied reference to a given file.
`DependencyGraph`	`getDependencyGraph()`
`Set<ICompilationUnit>`	`getDirectDependencies(ICompilationUnit cu)` Gets the set of compilation units depended on directly by the specified compilation unit.
`Set<ICompilationUnit>`	`getDirectReverseDependencies(ICompilationUnit cu, DependencyTypeSet types)` Gets the set of compilation units that directly depend on the specified compilation unit.
`Collection<ICompilerProblem>`	`getFatalProblems()` Check for fatal problems, that would prevent us from successfully compiling.
`Collection<ICompilationUnit>`	`getIncludingCompilationUnits(String filename)` Get all compilation units from which the filename is included.
`Collection<ICompilerProblem>`	`getProblems()`
`IProjectConfigVariables`	`getProjectConfigVariables()` Returns an `IProjectConfigVariables` struct that contains all the config data for this project
`List<ICompilationUnit>`	`getReachableCompilationUnitsInSWFOrder(Collection<ICompilationUnit> roots)` Given a set of roots node in the dependency graph, compute a list of `ICompilationUnit`'s that are reachable from the specified roots.
`ASProjectScope`	`getScope()`
`IDefinition`	`getUndefinedValue()` Helper method to get the only built-in value (undefined).
`boolean`	`getUseParallelCodeGeneration()` Gets a boolean that indicates whether or not parallel code generation of method bodies is enabled.
`Workspace`	`getWorkspace()`
`abstract boolean`	`handleAddedFile(File addedFile)` Called by `Workspace.fileAdded(org.apache.flex.compiler.filespecs.IFileSpecification)` for each project in the workspace.
`protected ASProjectScope`	`initProjectScope(CompilerProject project)` Init the project scope.
`boolean`	`isCompatibleOverrideReturnType(ITypeDefinition overrideDefinition, ITypeDefinition baseDefinition)`
`boolean`	`isInliningEnabled()` Test whether the project supports function inlining
`boolean`	`isValidTypeConversion(IASNode node, IDefinition actualDefinition, IDefinition expectedDefinition, FunctionDefinition func)`
`void`	`removeAnyUnfoundDependencies(ICompilationUnit compilationUnit)`
`void`	`removeCompilationUnit(ICompilationUnit unit)` Removes a `ICompilationUnit` from the project.
`void`	`removeCompilationUnits(Collection<ICompilationUnit> unitsToRemove)` Removes a set of `ICompilationUnit`'s from the project.
`void`	`removeDependencies(Collection<ICompilationUnit> units)` Removes the outgoing dependencies of a collection of `ICompilationUnit`.
`void`	`resetScopeCacheForCompilationUnit(ICompilationUnit compilationUnit)` Resets all the `ASScopeCache`s associated with the specified `ICompilationUnit`.
`ICompilationUnit`	`resolveQNameToCompilationUnit(String qName)` Resolve a QName such as `mx.controls.Button` to the containing ICompilationUnit
`IDefinition`	`resolveQNameToDefinition(String qName)` Resolve a QName such as `mx.controls.Button` to a class definition.
`void`	`setEnableInlining(boolean enableInlining)` Set whether or not function inlining is enabled.
`void`	`setProblems(Collection<ICompilerProblem> problems)` collection of compiler problems.
`void`	`setUseParallelCodeGeneration(boolean useParallelCodeGeneration)` Enables or disables parallel code generation of method bodies.
`void`	`unitTestingEntryPointForRemovingCompilationUnit(ICompilationUnit unit)` Don't call this from production code.
`void`	`updatePublicAndInternalDefinitions(Collection<ICompilationUnit> units)` Updates the `ASProjectScope` to contain reference to public and internal definitions in those compilation units.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.flex.compiler.projects.ICompilerProject
isAssetEmbeddingSupported

- Field Detail
  - targets
```
protected Set<Target> targets
```
  - problems
```
protected Collection<ICompilerProblem> problems
```
  - dependencyGraph
```
protected final DependencyGraph dependencyGraph
```
    Dependency graph is used to keep track of which ICompilationUnit 's are in this project. The dependency graph is in this shared base class instead of being in ASProject because ICompilationUnit implementations will want to update the dependency graph and ICompilationUnit implementations should be able to behave the same irrespective of what type of CompilerProject they are in.
- Constructor Detail
  - CompilerProject
```
public CompilerProject(Workspace workspace,
               boolean useAS3)
```
- Method Detail
  - initProjectScope
```
protected ASProjectScope initProjectScope(CompilerProject project)
```
    Init the project scope. Allow subclasses to contribute their own if needed. Default will create a new ASProjectScope
    
    Parameters:
    project - the project to build the scope from
    
    Returns:
    a new ASProjectScope
  - getScope
```
public ASProjectScope getScope()
```
    Specified by:
    
    getScope in interface ICompilerProject
    
    Returns:
    The project scope for the project. This scope object contains all the global definitions in the project.
  - getWorkspace
```
public Workspace getWorkspace()
```
    Specified by:
    
    getWorkspace in interface ICompilerProject
    
    Returns:
    The workspace in which this project lives.
  - getReachableCompilationUnitsInSWFOrder
```
public List<ICompilationUnit> getReachableCompilationUnitsInSWFOrder(Collection<ICompilationUnit> roots)
```
    Description copied from interface: ICompilerProject
    
    Given a set of roots node in the dependency graph, compute a list of ICompilationUnit's that are reachable from the specified roots. The returned list of ICompilationUnit's is in the order in which the ICompilationUnit's should be added to a SWF.
    
    Specified by:
    
    getReachableCompilationUnitsInSWFOrder in interface ICompilerProject
    
    Parameters:
    roots - The roots of the dependency graph that is walked to compute which CompilationUnits to include in the return value.
    
    Returns:
    A list of ICompilationUnit's reachable from the specified roots in the order the ICompilationUnit's should be added to a SWF.
  - updatePublicAndInternalDefinitions
```
public void updatePublicAndInternalDefinitions(Collection<ICompilationUnit> units)
                                        throws InterruptedException
```
    Updates the ASProjectScope to contain reference to public and internal definitions in those compilation units.
    
    Parameters:
    units - ICompilationUnit's to add to the project.
    
    Throws:
    
    InterruptedException
  - addCompilationUnitsAndUpdateDefinitions
```
public void addCompilationUnitsAndUpdateDefinitions(Collection<ICompilationUnit> compilationUnits)
                                             throws InterruptedException
```
    Adds compilation units to the project and updates the public and private definitions. Eventually this method should be removed, but it is convenient for testing because it allows custom created ICompilationUnit's to be injected into a project.
    
    Parameters:
    compilationUnits - A collection of compilation units.
    
    Throws:
    
    InterruptedException
  - addEmbedCompilationUnit
```
public void addEmbedCompilationUnit(EmbedCompilationUnit unit)
                             throws InterruptedException
```
    Throws:
    
    InterruptedException
  - addCompilationUnit
```
public void addCompilationUnit(ICompilationUnit unit)
```
    Add a ICompilationUnit to the project. Calling this method does not trigger the ICompilationUnit to be compiled.
    
    Parameters:
    unit - ICompilationUnit to add
  - addCompilationUnits
```
public void addCompilationUnits(Collection<ICompilationUnit> units)
```
    Add compilation units to the project. Calling this method does not trigger the compilation units to be compiled.
    
    Parameters:
    units - compilation units
  - removeCompilationUnit
```
public void removeCompilationUnit(ICompilationUnit unit)
```
    Removes a ICompilationUnit from the project.
    
    Parameters:
    unit - ICompilationUnit to remove.
  - unitTestingEntryPointForRemovingCompilationUnit
```
public void unitTestingEntryPointForRemovingCompilationUnit(ICompilationUnit unit)
```
    Don't call this from production code. Normally library managers take care of this. This function is only for unit tests.
  - removeCompilationUnits
```
public void removeCompilationUnits(Collection<ICompilationUnit> unitsToRemove)
```
    Removes a set of ICompilationUnit's from the project.
    
    Parameters:
    unitsToRemove - ICompilationUnit's to remove.
  - getCompilationUnits
```
public Collection<ICompilationUnit> getCompilationUnits()
```
    Specified by:
    
    getCompilationUnits in interface ICompilerProject
    
    Returns:
    All the compilation units in the project.
  - getCompilationUnits
```
public Collection<ICompilationUnit> getCompilationUnits(String filename)
```
    Description copied from interface: ICompilerProject
    
    Get all compilation units from the filename
    
    Specified by:
    
    getCompilationUnits in interface ICompilerProject
    
    Parameters:
    filename - path to source file
  - getIncludingCompilationUnits
```
public Collection<ICompilationUnit> getIncludingCompilationUnits(String filename)
```
    Description copied from interface: ICompilerProject
    
    Get all compilation units from which the filename is included.
    The returned collection does not include invisible compilation units.
    
    Specified by:
    
    getIncludingCompilationUnits in interface ICompilerProject
    
    Parameters:
    filename - path to source file
  - addUnfoundDefinitionDependency
```
public void addUnfoundDefinitionDependency(String definitionBaseName,
                                  ICompilationUnit compilationUnit)
```
  - getDependenciesOnUnfoundDefinition
```
public Set<ICompilationUnit> getDependenciesOnUnfoundDefinition(String definitionBaseName)
```
  - addUnfoundReferencedSourceFileDependency
```
public void addUnfoundReferencedSourceFileDependency(String sourceFilename,
                                            ICompilationUnit compilationUnit)
```
    Notify project that a compilation unit could not find a referenced file. "Referenced" here means that the compilation unit references the file in some way other than the normal language level manner. For example, embedded and included files are "referenced", whereas files that defined referenced types are not. Calling this function will allow incremental re-compiation to be kicked off when/if the required file comes into existence.
    
    Parameters:
    sourceFilename - The full path to the required file
    compilationUnit - The compilation unit that requires the referenced file
  - getDependenciesOnUnfoundReferencedSourceFile
```
public Set<ICompilationUnit> getDependenciesOnUnfoundReferencedSourceFile(String sourceFilename)
```
    gets the set of all compilation units that have an unsatisfied reference to a given file.
    
    Parameters:
    sourceFilename - The path to the file.
  - removeAnyUnfoundDependencies
```
public void removeAnyUnfoundDependencies(ICompilationUnit compilationUnit)
```
  - getDependenciesOnDefinition
```
public Set<ICompilationUnit> getDependenciesOnDefinition(String definitionBaseName)
```
  - clean
```
public void clean()
```
    Description copied from interface: ICompilerProject
    
    Removes all data created during a compile
    
    Specified by:
    
    clean in interface ICompilerProject
  - delete
```
public void delete()
```
    Description copied from interface: ICompilerProject
    
    Called before a project is deleted. This method will remove all compilation units associated with the project from the workspace, along with the project itself from the workspace. Once this method has been called, the project will no longer be in a valid state. SWC caches which are shared across projects will not be invalidated.
    
    Specified by:
    
    delete in interface ICompilerProject
  - createSWFTarget
```
public ISWFTarget createSWFTarget(ITargetSettings targetSettings,
                         ITargetProgressMonitor progressMonitor)
                           throws InterruptedException
```
    Description copied from interface: ICompilerProject
    
    Create a SWF target
    
    Specified by:
    
    createSWFTarget in interface ICompilerProject
    
    Parameters:
    targetSettings - The settings to use for this target
    progressMonitor - to collect progress information, can be null
    
    Returns:
    The newly created ISWFTarget
    
    Throws:
    
    InterruptedException
  - addDependency
```
public void addDependency(ICompilationUnit from,
                 ICompilationUnit to,
                 DependencyTypeSet dt,
                 String qname)
```
    Adds a dependency from one ICompilationUnit to another ICompilationUnit.
    
    Parameters:
    from - ICompilationUnit that depends on "to".
    to - ICompilationUnit that is depended on by "from".
    dt - The types of dependencies to add.
    qname - The qname of the target dependency added
  - addDependency
```
public void addDependency(ICompilationUnit from,
                 ICompilationUnit to,
                 DependencyType dt,
                 String qname)
```
    Adds a dependency from one ICompilationUnit to another ICompilationUnit.
    
    Parameters:
    from - ICompilationUnit that depends on "to".
    to - ICompilationUnit that is depended on by "from".
    dt - The type of dependency to add.
    qname - The qname of the target dependency added
  - addDependency
```
public void addDependency(ICompilationUnit from,
                 ICompilationUnit to,
                 DependencyType dt)
```
    Adds an anonymous dependency from one ICompilationUnit to another ICompilationUnit. This dependency will not be used in the link report.
    
    Parameters:
    from - ICompilationUnit that depends on "to".
    to - ICompilationUnit that is depended on by "from".
    dt - The type of dependency to add.
  - removeDependencies
```
public void removeDependencies(Collection<ICompilationUnit> units)
```
    Removes the outgoing dependencies of a collection of ICompilationUnit.
    
    Parameters:
    units - ICompilationUnit to remove dependencies from.
  - getDependencies
```
public Set<ICompilationUnit> getDependencies(ICompilationUnit cu)
                                      throws InterruptedException
```
    Gets the set of dependencies referenced by the specified ICompilationUnit. in the absence of wierd things like defaults/theme css, this is just the set of ICompilationUnit's that define definitions directly referenced by the specified ICompilationUnit.
    This method can be overridden by subclasses to add additional dependencies that are not in the dependency graph.
    
    Parameters:
    cu - ICompilationUnit to retrieve dependencies for.
    
    Returns:
    A new Set of ICompilationUnit's that the specified ICompilationUnit directly depends on.
    
    Throws:
    
    InterruptedException
  - collectProblems
```
public abstract void collectProblems(Collection<ICompilerProblem> problems)
```
    Gets project level ICompilerProblem's target are not specific to any one target created by the project.
  - collectConfigProblems
```
protected void collectConfigProblems(Collection<ICompilerProblem> problems)
```
    Gets the project level ICompilerProblem's that come from parsing the config options, from the command line, or a configuration file
    
    Parameters:
    problems - the Collection to add the config problems to.
  - getCacheForScope
```
public ASScopeCache getCacheForScope(ASScope scope)
```
    Get the cache for a particular scope
    
    Parameters:
    scope - the scope you want the cache for.
    
    Returns:
    the ASScopeCache for the scope
  - clearScopeCacheForCompilationUnit
```
public void clearScopeCacheForCompilationUnit(ICompilationUnit compilationUnit)
```
    Clears all the ASScopeCaches associated with the specified ICompilationUnit and removes all the IASScopes build by the ICompilationUnit from the list of scopes associated with the ICompilationUnit. This method should only be called when a ICompilationUnit is being removed from a project.
    
    Parameters:
    compilationUnit - ICompilationUnit whose scope caches should be cleared and whose scope list should be emptied.
  - resetScopeCacheForCompilationUnit
```
public void resetScopeCacheForCompilationUnit(ICompilationUnit compilationUnit)
```
    Resets all the ASScopeCaches associated with the specified ICompilationUnit.
    
    Parameters:
    compilationUnit - ICompilationUnit whose scope caches should be cleared
  - addGlobalUsedNamespacesToNamespaceSet
```
public void addGlobalUsedNamespacesToNamespaceSet(Set<INamespaceDefinition> nsSet)
```
  - handleAddedFile
```
public abstract boolean handleAddedFile(File addedFile)
```
    Called by Workspace.fileAdded(org.apache.flex.compiler.filespecs.IFileSpecification) for each project in the workspace. Each subclass of this class must decide when an added file is interesting or should be ignored.
    
    Parameters:
    addedFile - File that was added.
    
    Returns:
    true if any new compilation units were created as a result of adding the file, false otherwise.
  - getCompilationUnit
```
public EmbedCompilationUnit getCompilationUnit(EmbedData data)
```
    Return the compilation unit related this EmbedData, or it's equivalent. If there is no equiv., null will be returned
    
    Parameters:
    data - The embedding data.
    
    Returns:
    related EmbedCompilationUnit. Can be null
  - getDependencyGraph
```
public final DependencyGraph getDependencyGraph()
```
  - addConfigVariables
```
public void addConfigVariables(Map<String,String> map)
```
    Sets project config variables for use on this project
    
    Parameters:
    map - the mapping of config names to their expressions
    See Also:
    ConfigManager.addConfigVariables(Map)
  - addConfigVariable
```
public void addConfigVariable(String namespace,
                     String expression)
```
    Sets project config variable for use on this project
    
    Parameters:
    namespace - the config namespace
    expression - the config expression for the namespace
    See Also:
    ConfigManager.addConfigVariables(Map)
  - getProjectConfigVariables
```
public IProjectConfigVariables getProjectConfigVariables()
```
    Returns an IProjectConfigVariables struct that contains all the config data for this project
    
    Returns:
    an IProjectConfigVariables object, never null
  - resolveQNameToDefinition
```
public IDefinition resolveQNameToDefinition(String qName)
```
    Description copied from interface: ICompilerProject
    
    Resolve a QName such as mx.controls.Button to a class definition.
    
    Specified by:
    
    resolveQNameToDefinition in interface ICompilerProject
    
    Parameters:
    qName - Qualified name.
    
    Returns:
    The IDefinition corresponds to the given QName; Null if the name can't be resolved.
  - resolveQNameToCompilationUnit
```
public ICompilationUnit resolveQNameToCompilationUnit(String qName)
```
    Description copied from interface: ICompilerProject
    
    Resolve a QName such as mx.controls.Button to the containing ICompilationUnit
    
    Specified by:
    
    resolveQNameToCompilationUnit in interface ICompilerProject
    
    Parameters:
    qName - Qualified name.
    
    Returns:
    The ICompilationUnit corresponds to the given QName; Null if the name can't be resolved.
  - getFatalProblems
```
public Collection<ICompilerProblem> getFatalProblems()
```
    Check for fatal problems, that would prevent us from successfully compiling. Currently this just checks that all of the builtin types are present.
  - getBuiltinType
```
public ITypeDefinition getBuiltinType(IASLanguageConstants.BuiltinType type)
```
    Description copied from interface: ICompilerProject
    
    Helper method to get some of the built-in types (*, String, Number, etc). Looks right in the project scope, so won't find any intervening definitions that could hide a built-in.
    
    Specified by:
    
    getBuiltinType in interface ICompilerProject
  - getUndefinedValue
```
public IDefinition getUndefinedValue()
```
    Description copied from interface: ICompilerProject
    
    Helper method to get the only built-in value (undefined). Looks right in the project scope, so won't find any intervening definitions that could hide a built-in.
    
    Specified by:
    
    getUndefinedValue in interface ICompilerProject
    
    Returns:
    the definition for the constant whose qname is "undefined". Note that if we add more built-in values we will need to change this api to take an enum, just like getBuiltinType().
  - getUseParallelCodeGeneration
```
public boolean getUseParallelCodeGeneration()
```
    Gets a boolean that indicates whether or not parallel code generation of method bodies is enabled.
    
    Returns:
    true if method bodies should be generated in parallel, false otherwise.
  - setUseParallelCodeGeneration
```
public void setUseParallelCodeGeneration(boolean useParallelCodeGeneration)
```
    Description copied from interface: ICompilerProject
    
    Enables or disables parallel code generation of method bodies.
    
    Specified by:
    
    setUseParallelCodeGeneration in interface ICompilerProject
    
    Parameters:
    useParallelCodeGeneration - If true, method bodies will be generated in parallel.
  - getDirectDependencies
```
public Set<ICompilationUnit> getDirectDependencies(ICompilationUnit cu)
```
    Description copied from interface: ICompilerProject
    
    Gets the set of compilation units depended on directly by the specified compilation unit.
    
    Specified by:
    
    getDirectDependencies in interface ICompilerProject
    
    Parameters:
    cu - The ICompilationUnit whose set of direct dependencies will be returned.
    
    Returns:
    A new set of compilation units that the specified compilation unit directly depends on.
  - getDirectReverseDependencies
```
public Set<ICompilationUnit> getDirectReverseDependencies(ICompilationUnit cu,
                                                 DependencyTypeSet types)
```
    Description copied from interface: ICompilerProject
    
    Gets the set of compilation units that directly depend on the specified compilation unit.
    
    Specified by:
    
    getDirectReverseDependencies in interface ICompilerProject
    
    Parameters:
    cu - An ICompilationUnit.
    types - A DependencyTypeSet of dependency types used to filter the returned set of compilation units.
    
    Returns:
    A new set of compilation units that directly depend on the specified compilation unit.
  - isInliningEnabled
```
public boolean isInliningEnabled()
```
    Description copied from interface: ICompilerProject
    
    Test whether the project supports function inlining
    
    Specified by:
    
    isInliningEnabled in interface ICompilerProject
    
    Returns:
    true if inlining enabled, false otherwise.
  - setEnableInlining
```
public void setEnableInlining(boolean enableInlining)
```
    Set whether or not function inlining is enabled.
    
    Parameters:
    enableInlining - true to enable inlining.
  - addToASTCache
```
public void addToASTCache(IASNode ast)
```
    Add AST to cache. By default, not added to any cache.
    
    Parameters:
    ast - The AST.
  - getActualPackageName
```
public String getActualPackageName(String packageName)
```
    Override this to permit package aliasing on imports and elsewhere
    
    Specified by:
    
    getActualPackageName in interface ICompilerProject
    
    Parameters:
    packageName - The package name
  - doubleCheckAmbiguousDefinition
```
public IDefinition doubleCheckAmbiguousDefinition(ASScope scope,
                                         String name,
                                         IDefinition def1,
                                         IDefinition def2)
```
    Override this to disambiguate between two ambiguous definitinos
    
    Specified by:
    
    doubleCheckAmbiguousDefinition in interface ICompilerProject
    
    Parameters:
    scope - The current scope.
    name - Definition name.
    def1 - One possibility.
    def2 - The other possibility.
    
    Returns:
    null if still ambiguous or else def1 or def2.
  - getProblems
```
public Collection<ICompilerProblem> getProblems()
```
    Specified by:
    
    getProblems in interface ICompilerProject
    
    Returns:
    collection of compiler problems.
  - setProblems
```
public void setProblems(Collection<ICompilerProblem> problems)
```
    collection of compiler problems.
    
    Specified by:
    
    setProblems in interface ICompilerProject
    
    Parameters:
    problems - All the problems collected so far. Set this to the main collection so parts of the compiler can add a problem if they don't have another place to add them.
  - isCompatibleOverrideReturnType
```
public boolean isCompatibleOverrideReturnType(ITypeDefinition overrideDefinition,
                                     ITypeDefinition baseDefinition)
```
    Specified by:
    
    isCompatibleOverrideReturnType in interface ICompilerProject
    
    Parameters:
    overrideDefinition - The definition overriding the base definition.
    baseDefinition - The definition being overridden.
    
    Returns:
    True if compatible (default is if they are the same)
  - isValidTypeConversion
```
public boolean isValidTypeConversion(IASNode node,
                            IDefinition actualDefinition,
                            IDefinition expectedDefinition,
                            FunctionDefinition func)
```
    Specified by:
    
    isValidTypeConversion in interface ICompilerProject
    
    Parameters:
    node - The node being converted.
    actualDefinition - The actual definition.
    expectedDefinition - The expected definition.
    func - The function being called.
    
    Returns:
    True if valid

Class CompilerProject

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.flex.compiler.projects.ICompilerProject

Field Detail

targets

problems

dependencyGraph

Constructor Detail

CompilerProject

Method Detail

initProjectScope

getScope

getWorkspace

getReachableCompilationUnitsInSWFOrder

updatePublicAndInternalDefinitions

addCompilationUnitsAndUpdateDefinitions

addEmbedCompilationUnit

addCompilationUnit

addCompilationUnits

removeCompilationUnit

unitTestingEntryPointForRemovingCompilationUnit

removeCompilationUnits

getCompilationUnits

getCompilationUnits

getIncludingCompilationUnits

addUnfoundDefinitionDependency

getDependenciesOnUnfoundDefinition

addUnfoundReferencedSourceFileDependency

getDependenciesOnUnfoundReferencedSourceFile

removeAnyUnfoundDependencies

getDependenciesOnDefinition

clean

delete

createSWFTarget

addDependency

addDependency

addDependency

removeDependencies

getDependencies

collectProblems

collectConfigProblems

getCacheForScope

clearScopeCacheForCompilationUnit

resetScopeCacheForCompilationUnit

addGlobalUsedNamespacesToNamespaceSet

handleAddedFile

getCompilationUnit

getDependencyGraph

addConfigVariables

addConfigVariable

getProjectConfigVariables

resolveQNameToDefinition

resolveQNameToCompilationUnit

getFatalProblems

getBuiltinType

getUndefinedValue

getUseParallelCodeGeneration

setUseParallelCodeGeneration

getDirectDependencies

getDirectReverseDependencies

isInliningEnabled

setEnableInlining

addToASTCache

getActualPackageName

doubleCheckAmbiguousDefinition

getProblems

setProblems

isCompatibleOverrideReturnType

isValidTypeConversion