/*
*
* 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.flex.compiler.internal.scopes;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.flex.compiler.common.ASImportTarget;
import org.apache.flex.compiler.common.DependencyType;
import org.apache.flex.compiler.common.IImportTarget;
import org.apache.flex.compiler.common.NodeReference;
import org.apache.flex.compiler.constants.IASLanguageConstants;
import org.apache.flex.compiler.definitions.IClassDefinition;
import org.apache.flex.compiler.definitions.IDefinition;
import org.apache.flex.compiler.definitions.INamespaceDefinition;
import org.apache.flex.compiler.definitions.IQualifiers;
import org.apache.flex.compiler.definitions.IScopedDefinition;
import org.apache.flex.compiler.definitions.references.INamespaceReference;
import org.apache.flex.compiler.internal.definitions.AmbiguousDefinition;
import org.apache.flex.compiler.internal.definitions.ClassDefinition;
import org.apache.flex.compiler.internal.definitions.ClassDefinitionBase;
import org.apache.flex.compiler.internal.definitions.FunctionDefinition;
import org.apache.flex.compiler.internal.definitions.InterfaceDefinition;
import org.apache.flex.compiler.internal.definitions.NamespaceDefinition;
import org.apache.flex.compiler.internal.definitions.ScopedDefinitionBase;
import org.apache.flex.compiler.internal.projects.CompilerProject;
import org.apache.flex.compiler.internal.tree.as.ScopedBlockNode;
import org.apache.flex.compiler.internal.workspaces.Workspace;
import org.apache.flex.compiler.projects.ICompilerProject;
import org.apache.flex.compiler.scopes.IDefinitionSet;
import org.apache.flex.compiler.tree.as.IScopedNode;
import org.apache.flex.compiler.units.ICompilationUnit;
import org.apache.flex.compiler.workspaces.IWorkspace;
import org.apache.flex.utils.CheapArray;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableSet;
/**
* IASScope implementation for class, interface, function, and 'with' scopes.
*/
public abstract class ASScope extends ASScopeBase
{
private static String[] EMPTY_STRING_ARRAY = new String[0];
protected static final NamespaceDefinition.IUseNamespaceDirective[] EMPTY_USE_ARRAY =
new NamespaceDefinition.IUseNamespaceDirective[0];
/**
* Constructor
*
* @param block block node to which this scope belongs
*/
public ASScope(ASScope containingScope, ScopedBlockNode block)
{
super();
setContainingScope(containingScope);
if (block != null)
{
block.setScope(this);
// Node reference constructor only works
// if the setContainingScope has already be called
// above.
scopedNodeRef = new NodeReference(block);
}
}
public ASScope(ASScope containingScope)
{
this(containingScope, null);
}
private ASScope containingScope;
/**
* Weak ref back to the Block node to which this scope belongs TODO: Remove
* once code model clients don't depend on this anymore
*/
protected NodeReference scopedNodeRef = NodeReference.noReference;
/**
* List of all imports in scope
*/
private Object importsInScope = null;
private Set<String> packageNames = null;
private Object usedNamespaces = null;
private NamespaceDefinition.INamespaceDirective firstNamespaceDirective;
private NamespaceDefinition.INamespaceDirective lastNamespaceDirective;
private boolean inWith = false;
/**
* Sets the scope which lexically contains this scope.
*
* @param containingScope The containing scope.
*/
public void setContainingScope(ASScope containingScope)
{
this.containingScope = containingScope;
// calc this once, as it shouldn't change
this.inWith = getContainingWithScope() != null;
}
/**
* Compact the ArrayLists in this scope (so that they don't take up as much
* space)
*/
@Override
public void compact()
{
super.compact();
if (importsInScope != null)
CheapArray.optimize(importsInScope, EMPTY_STRING_ARRAY);
if (usedNamespaces != null)
CheapArray.optimize(usedNamespaces, EMPTY_USE_ARRAY);
}
public void addNamespaceDirective(NamespaceDefinition.INamespaceDirective directive)
{
if (lastNamespaceDirective != null)
{
lastNamespaceDirective.setNext(directive);
lastNamespaceDirective = directive;
}
else
{
assert firstNamespaceDirective == null;
firstNamespaceDirective = directive;
lastNamespaceDirective = directive;
}
}
public void addUseDirective(NamespaceDefinition.IUseNamespaceDirective useDirective)
{
addNamespaceDirective(useDirective);
if (usedNamespaces == null)
usedNamespaces = CheapArray.create(1);
CheapArray.add(useDirective, usedNamespaces);
}
public void addImport(String target)
{
if (importsInScope == null)
{
importsInScope = CheapArray.create(20);
packageNames = new HashSet<String>();
}
CheapArray.add(target, importsInScope);
int idx = target.lastIndexOf('.');
if (idx != -1)
{
String packName = target.substring(0, idx);
if (!target.endsWith(".*"))
{
// If this is not a wildcard import, then add the imported name
// to the importedNames table so we can construct the right namespace
// set for that name when we see a reference to it.
String defName = target.substring(idx + 1, target.length());
if (importedNames == null)
importedNames = new HashMap<String, Set<String>>();
Set<String> s = importedNames.get(defName);
if (s == null)
{
s = new LinkedHashSet<String>();
importedNames.put(defName, s);
}
s.add(packName);
}
// Whether the import was a wildcard or not, the packageName contributes to the
// set of known package names.
packageNames.add(packName);
}
}
@Override
public ASScope getContainingScope()
{
return containingScope;
}
/**
* Re-connects this scope to the syntax tree node that corresponds to this
* scope.
*
* @param node {@link IScopedNode} that corresponds to this scope.
*/
public void reconnectScopeNode(IScopedNode node)
{
scopedNodeRef.reconnectNode(node);
}
@Override
public IScopedNode getScopeNode()
{
IWorkspace w = getWorkspace();
return (IScopedNode)scopedNodeRef.getNode(w, this);
}
public String[] getImports()
{
return (String[])CheapArray.toArray(importsInScope, EMPTY_STRING_ARRAY);
}
private ScopedDefinitionBase containingDefinition;
@Override
public ScopedDefinitionBase getDefinition()
{
return containingDefinition;
}
public void setContainingDefinition(ScopedDefinitionBase value)
{
containingDefinition = value;
}
/**
* For debugging only.
*/
@Override
protected String toStringHeader()
{
StringBuilder sb = new StringBuilder();
sb.append(super.toStringHeader());
IDefinition definition = getDefinition();
if (definition != null)
{
sb.append(" for ");
sb.append(definition.toString());
}
return sb.toString();
}
/**
* Determine whether the string passed in is a known package name The scope
* will check if the package was introduced by any of it's imports, and if
* not will delegate to its containing scope.
*
* @param p the string to test
* @return true is p is a package name
*/
public boolean isPackageName(String p)
{
if (packageNames != null)
{
if (packageNames.contains(p))
{
return true;
}
}
if (containingScope != null)
return containingScope.isPackageName(p);
return false;
}
/**
* Return the additional namespaces for a reference, if the name has been
* explicitly imported. If 'a.b.Foo' has been imported, and we see reference
* to Foo, this will return the INamespaceDefinition for 'a.b'. If the name
* has not been explicitly imported then this method will return the empty
* set.
*
* @param project CompilerProject to use to resolve the package INamespaces
* @param name The name of the reference
* @return A Set<INamespaceDefinition> representing the packages from the
* imports if the name was explicitly imported. Returns the empty set if the
* name was not explicitly imported.
*/
public Set<INamespaceDefinition> getExplicitImportQualifiers(CompilerProject project, String name)
{
Set<INamespaceDefinition> nsSet = new LinkedHashSet<INamespaceDefinition>();
Workspace workspace = project.getWorkspace();
getContainingScopeExplicitImports(project, name, nsSet);
if (importedNames != null)
{
// Was it an import in this scope
Set<String> packages = importedNames.get(name);
if (packages != null)
{
for (String s : packages)
{
nsSet.add(workspace.getPackageNamespaceDefinitionCache().get(s, false));
}
}
}
return nsSet.size() > 0 ? nsSet : Collections.<INamespaceDefinition> emptySet();
}
/**
* Get the additional namespaces for a reference, if the name has been explicitly imported in
* a containing scope
* @param project the active project
* @param name the name of the reference
* @param nsSet the namespace set to add the namespaces to
*/
protected void getContainingScopeExplicitImports (CompilerProject project, String name, Set<INamespaceDefinition> nsSet)
{
if (getContainingScope() != null)
{
// check any containing scopes
nsSet.addAll(getContainingScope().getExplicitImportQualifiers(project, name));
}
}
/**
* Maps names to the package name used to look them up - this is used to
* store explicit imports of definitions (import a.b.Foo)
*/
private Map<String, Set<String>> importedNames;
protected INamespaceReference[] getUsedNamespaces()
{
return (INamespaceReference[])CheapArray.toArray(usedNamespaces, EMPTY_USE_ARRAY);
}
/**
* Gets the first namespace definition or use namespace directive in the
* scope.
*
* @return The first namespace definition or use namespace directive in the
* scope.
*/
public NamespaceDefinition.INamespaceDirective getFirstNamespaceDirective()
{
return firstNamespaceDirective;
}
/**
* Adds {@link INamespaceDefinition}'s for each import in this scope to the
* specified namespace set.
*
* @param workspace {@link IWorkspace} used to construct
* {@link INamespaceDefinition}'s for imported packages.
* @param namespaceSet Namespace set to add namespaces to.
*/
public void addLocalImportsToNamespaceSet(IWorkspace workspace, Set<INamespaceDefinition> namespaceSet)
{
String[] imports = getImports();
if (imports != null)
{
for (String importStr : imports)
{
IImportTarget importTarget = ASImportTarget.get(workspace, importStr);
// Only wildcard imports contribute to the namespace set
// e.g. a.b.*, but not a.b.Foo
if (importTarget.isWildcard())
namespaceSet.add(importTarget.getNamespace());
}
}
}
/**
* Calculate the namespace set to use to resolve name. If name is an
* explicitly imported definition, then the namespace set will consist of
* the package name from the import(s) plus the open namespace set. If name
* was not explitly imported then the open namespace set will be calculated
* and returned
*
* @param project The compiler project
* @param name A name.
* @return the namespace set to use to lookup name. This set should not be
* modified
*/
public Set<INamespaceDefinition> getNamespaceSetForName(ICompilerProject project, String name)
{
if (namespaceSetSameAsContainingScopeNamespaceSet() && getContainingScope() != null)
{
// If this scope doesn't contribute anything to the namespace set, then just ask our containing
// scope for the namespace set. Doing this before we hit the cache has the benefit that the
// namespace set will only get cached in the containing scopes cache, instead of getting cached
// in each individual scope cache (e.g. it will be cached in the class scope, instead of in each function
// scope in the class). This saves a lot of memory, as many functions will not affect the list
// of open namespaces.
return getContainingScope().getNamespaceSetForName(project, name);
}
CompilerProject compilerProject = (CompilerProject)project;
ASScopeCache scopeCache = compilerProject.getCacheForScope(this);
return scopeCache.getNamespaceSetForName(name);
}
protected boolean namespaceSetSameAsContainingScopeNamespaceSet()
{
if ((getImports() != null) || (getUsedNamespaces() != null))
return false;
// function with no namespace set modifications, so reuse
if (containingDefinition instanceof FunctionDefinition)
return true;
// TODO: can with scopes also be optimized here?
return false;
}
/**
* Implementation of getNamespaceSetForName method, above. The scope cache
* will call this method when it does not already have the results cached
*
* @param project
* @param name
* @return the namespace set to use to lookup name. This set should not be
* modified
*/
Set<INamespaceDefinition> getNamespaceSetForNameImpl(ICompilerProject project, String name)
{
if (namespaceSetSameAsContainingScopeNamespaceSet())
{
ASScope containingScope = getContainingScope();
if (containingScope != null)
{
return containingScope.getNamespaceSetForName(project, name);
}
}
Set<INamespaceDefinition> openNamespaces = getNamespaceSet(project);
// If the reference has been explicitly imported, then we are a qualified name lookup
// e.g. 'import a.b.Foo' means that any reference to Foo must have the package namespace of 'a.b' added
// to its set of namespaces
Set<INamespaceDefinition> additionalNamespaces = getExplicitImportQualifiers((CompilerProject)project, name);
if (additionalNamespaces != null)
{
Set<INamespaceDefinition> newSet = new LinkedHashSet<INamespaceDefinition>();
newSet.addAll(openNamespaces);
newSet.addAll(additionalNamespaces);
return newSet;
}
else
{
return openNamespaces;
}
}
/**
* Computes and returns the namespace set for this scope.
* <p>
* The returned set should not be modified.
*
* @param project The compiler project.
* @return The namespace set for this scope. The returned set should not be
* modified
*/
public Set<INamespaceDefinition> getNamespaceSet(ICompilerProject project)
{
CompilerProject compilerProject = (CompilerProject)project;
ASScopeCache scopeCache = compilerProject.getCacheForScope(this);
return scopeCache.getNamespaceSet();
}
/**
* Computes and returns the namespace set for this scope. This is the
* implementation of getNamespaceSet above. The scope cache will call this
* method when it does not have a cached result for the namespace set.
* <p>
* The returned set should not be modified.
*
* @param project
* @return The namespace set for this scope. The returned set should not be
* modified
*/
Set<INamespaceDefinition> getNamespaceSetImpl(ICompilerProject project)
{
if (namespaceSetSameAsContainingScopeNamespaceSet())
{
ASScope containingScope = getContainingScope();
if (containingScope != null)
{
return containingScope.getNamespaceSetImpl(project);
}
}
CompilerProject compilerProject = (CompilerProject)project;
IWorkspace workspace = compilerProject.getWorkspace();
Set<INamespaceDefinition> result = new LinkedHashSet<INamespaceDefinition>();
// First add the imports, use namespaces, etc from this scope
this.addLocalImportsToNamespaceSet(workspace, result);
INamespaceReference[] usedNamespaces = this.getUsedNamespaces();
if (usedNamespaces != null)
{
for (INamespaceReference usedNamespaceReference : usedNamespaces)
{
INamespaceDefinition usedNamespace = usedNamespaceReference.resolveNamespaceReference(compilerProject);
if (usedNamespace != null)
result.add(usedNamespace);
}
}
this.addImplicitOpenNamespaces(compilerProject, result);
// Next add the open namespaces from the containing scope
addNamespacesFromContainingScope(compilerProject, result);
Set<INamespaceDefinition> emptyNamespaceSet = Collections.emptySet();
result = result.size() == 0 ? emptyNamespaceSet : result;
return result;
}
/**
* Add the open namespaces from the containing scope to the namespace set passed in
* @param compilerProject the active project
* @param result the Namespace Set to add namespaces to
*/
protected void addNamespacesFromContainingScope (CompilerProject compilerProject, Set<INamespaceDefinition> result)
{
ASScope containingScope = this.getContainingScope();
if (containingScope != null)
{
result.addAll(containingScope.getNamespaceSet(compilerProject));
}
}
public void addImplicitOpenNamespaces(CompilerProject compilerProject, Set<INamespaceDefinition> result)
{
// By default there is nothing to do here.
// overrides in ASFileScope, PackageScope, and TypeScope.
}
/**
* Adds all definitions ( including definitions from base types ) in the
* current scope to the specified collections of definitions that have a
* namespace qualifier in the specified definition set, when looking for
* definitions in the scope chain.
*
* @param project {@link CompilerProject} used to resolve reference to
* definitions outside of the {@link ICompilationUnit} that contains this
* scope.
* @param defs Collection that found {@link IDefinition}'s are added to.
* @param namespaceSet Namespace set in which the qualifier of any matching
* definition must exist to be considered a match.
*/
public void getAllPropertiesForScopeChain(CompilerProject project, Collection<IDefinition> defs, Set<INamespaceDefinition> namespaceSet)
{
getAllLocalProperties(project, defs, namespaceSet, null);
}
/**
* Adds all definitions ( including definitions from base types ) in the
* current scope to the specified collections of definitions that have a
* namespace qualifier in the specified definition set, when looking for
* definitions through a member access.
*
* @param project {@link CompilerProject} used to resolve reference to
* definitions outside of the {@link ICompilationUnit} that contains this
* scope.
* @param defs Collection that found {@link IDefinition}'s are added to.
* @param namespaceSet Namespace set in which the qualifier of any matching
* definition must exist to be considered a match.
*/
public void getAllPropertiesForMemberAccess(CompilerProject project, Collection<IDefinition> defs, Set<INamespaceDefinition> namespaceSet)
{
getAllLocalProperties(project, defs, namespaceSet, null);
}
/**
* Gets all definitions (including definitions from base types) that have
* the specified name to the specified collections of definitions that have
* a namespace qualifier in the specified definition set, when looking for
* definitions through a member access.
*
* @param project {@link CompilerProject} used to resolve reference to
* definitions outside of the {@link ICompilationUnit} that contains this
* scope.
* @param memberName the name of the desired definition(s).
* @param namespaceSet Namespace set in which the qualifier of any matching
* definition must exist to be considered a match.
* @return the collection of matching definitions.
*/
public List<IDefinition> getPropertiesByNameForMemberAccess(CompilerProject project, String memberName, Set<INamespaceDefinition> namespaceSet)
{
// Get the collection of all properties.
List<IDefinition> result = new ArrayList<IDefinition>();
getPropertyForMemberAccess(project, result, memberName, namespaceSet, true);
return result;
}
/**
* Gets the definition (including definitions from base types) that has
* the specified name and that has a namespace qualifier in the specified
* namespace set, when looking for definitions through a member access.
*
* @param project {@link CompilerProject} used to resolve reference to
* definitions outside of the {@link ICompilationUnit} that contains this
* scope.
* @param memberName the name of the desired definition(s).
* @param namespaceSet Namespace set in which the qualifier of any matching
* definition must exist to be considered a match.
* @return The first definition that matches the name and namespaceSet. May return the AmbiguousDefinition
* if more than one definition in a scope matches.
*/
public IDefinition getPropertyByNameForMemberAccess(CompilerProject project, String memberName, Set<INamespaceDefinition> namespaceSet)
{
List<IDefinition> defs = new ArrayList<IDefinition>();
getPropertyForMemberAccess(project, defs, memberName, namespaceSet, false);
return getSingleResult(project, defs);
}
/**
* Finds all the definitions in this scope that match the specified
* namespace set and base name. This method is intended to implement the
* getproperty operation defined by AS3 and the VM.
* <p>
* If this scope is not for a class or interface definition then only
* definitions in this scope are considered.
* <p>
* If this scope is for a class or interface definition then definitions in
* this scope and the scope for any implemented or extended interfaces and
* classes are also considered. Unless findAll is true, then this function
* returns as soon as one or more definitions has been found that match the
* namespace set and base name.
* <p>
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param defs Collection of {@link IDefinition}'s to add found definitions
* to.
* @param baseName The name of the definition(s) to find.
* @param namespaceSet The namespace set in which a found definition's
* qualifier must be in.
* @param findAll If true find all match definitions that match the baseName
* and namespace set not just those in the first scope that had one or more
* matches.
*/
public void getPropertyForMemberAccess(CompilerProject project, Collection<IDefinition> defs, String baseName, Set<INamespaceDefinition> namespaceSet, boolean findAll)
{
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, namespaceSet);
Collection<IDefinition> filteredDefs = new FilteredCollection<IDefinition>(nsPred, defs);
getPropertyForMemberAccess(project, filteredDefs, baseName, nsPred, findAll);
}
/**
* Finds all the definitions in this scope that match the specified
* namespace set and base name. This method is intended to implement the
* getproperty operation defined by AS3 and the VM.
* <p>
* This version of the method expects that the Collection passed in will implement
* whatever filtering is necessary, other than filtering based on the base name.
* For most cases, this means the Collection will be an {@link ASScopeBase.FilteredCollection}
* with a {@link NamespaceSetPredicate}.
* The {@link NamespaceSetPredicate} must also be passed down as some name resolution
* may need it to apply extra namespaces (i.e. deal with protected namespaces)
*
* <p>
* If this scope is not for a class or interface definition then only
* definitions in this scope are considered.
* <p>
* If this scope is for a class or interface definition then definitions in
* this scope and the scope for any implemented or extended interfaces and
* classes are also considered. Unless findAll is true, then this function
* returns as soon as one or more definitions has been found that match the
* namespace set and base name.
* <p>
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param defs Collection of {@link IDefinition}'s to add found definitions
* to. This collection must perform any necessary filtering of results, other than filtering
* based on the baseName.
* @param baseName The name of the definition(s) to find.
* @param namespaceSet The {@link NamespaceSetPredicate} which the name resolution code
* can use to modify the namespace set as necessary.
* @param findAll If true find all match definitions that match the baseName
* and namespace set not just those in the first scope that had one or more
* matches.
*/
protected void getPropertyForMemberAccess(CompilerProject project, Collection<IDefinition> defs, String baseName, NamespaceSetPredicate namespaceSet, boolean findAll)
{
getLocalProperty(project, defs, baseName, true);
}
/**
* Helper method to get a namespace set for a member access
*/
private Set<INamespaceDefinition> getNamespaceSetForMemberAccess(ICompilerProject project, IDefinition def, boolean isSuperRef)
{
Set<INamespaceDefinition> namespaceSet;
if (def instanceof InterfaceDefinition)
// If we are getting a property from an interface, use the special interface namespace set
namespaceSet = ((InterfaceDefinition)def).getInterfaceNamespaceSet(project);
else if (isSuperRef)
namespaceSet = getNamespaceSetForSuper(project, def);
else
{
namespaceSet = getNamespaceSet(project);
// If the expression a.b occurs inside the class definition for a's type A,
// then add A's protected namespace so that we can see a protected b.
if (def == getContainingClass())
namespaceSet.add(((IClassDefinition)def).getProtectedNamespaceReference());
}
return namespaceSet;
}
/**
* Find a property in an IDefinition, using the open namespaces & packages
* of this scope.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param def The definition to resolve the property in
* @param name The name of the definition to find
* @param isSuperRef whether this lookup is through a 'super' reference - if
* it is then the namespace set will be adjusted to use the base classes
* protected namespace instead of the containing classes protected namespace
* @return The IDefinition for the property, or null if one is not found
*/
public IDefinition getPropertyFromDef(ICompilerProject project, IDefinition def, String name, boolean isSuperRef)
{
CompilerProject compilerProject = (CompilerProject)project;
Set<INamespaceDefinition> namespaceSet = getNamespaceSetForMemberAccess(project, def, isSuperRef);
return getPropertyFromDef(compilerProject, def, name, namespaceSet, false);
}
/**
* Find a property in an IDefinition, using the open namespaces & packages
* of this scope, and any additional constraints that are passed in as a {@link Predicate}.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param def The definition to resolve the property in
* @param name The name of the definition to find
* @param additional A {@link Predicate} that will perform additional filtering of the results.
* This {@link Predicate} will run before any namespace set checking.
* @param isSuperRef whether this lookup is through a 'super' reference - if
* it is then the namespace set will be adjusted to use the base classes
* protected namespace instead of the containing classes protected namespace
* @return The IDefinition for the property, or null if one is not found
*/
public IDefinition getPropertyFromDef(ICompilerProject project,
IDefinition def,
String name,
Predicate<IDefinition> additional,
boolean isSuperRef)
{
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, getNamespaceSetForMemberAccess(project, def, isSuperRef));
Predicate<IDefinition> combinedPred = Predicates.and(additional, nsPred);
return getPropertyFromDef((CompilerProject)project, def, name, combinedPred, nsPred, isSuperRef);
}
/**
* Find a property in an IDefinition, using the namespace passed in as the
* qualifier.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve references.
* @param def The definition to resolve the property in
* @param name The name of the definition to find
* @param qualifier The namespace to us to look up name
* @param isSuperRef whether this lookup is through a 'super' reference - if
* it is then the namespace set will be adjusted to use the base classes
* protected namespace instead of the containing classes protected namespace
* @return The IDefinition for the property, or null if one is not found
*/
public IDefinition getQualifiedPropertyFromDef(ICompilerProject project, IDefinition def, String name,
INamespaceDefinition qualifier, boolean isSuperRef)
{
Set<INamespaceDefinition> namespaceSet = ImmutableSet.of(qualifier);
if (isSuperRef)
namespaceSet = adjustNamespaceSetForSuper(def, namespaceSet);
return getPropertyFromDef((CompilerProject)project, def, name, namespaceSet, false);
}
/**
* Find a property in an IDefinition, using the qualifiers passed in to provide the namespace set.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve references.
* @param def The definition to resolve the property in
* @param name The name of the definition to find
* @param qualifiers The namespace(s) to us to look up name
* @param isSuperRef whether this lookup is through a 'super' reference - if
* it is then the namespace set will be adjusted to use the base classes
* protected namespace instead of the containing classes protected namespace
* @return The IDefinition for the property, or null if one is not found
*/
public IDefinition getQualifiedPropertyFromDef(ICompilerProject project, IDefinition def, String name,
IQualifiers qualifiers, boolean isSuperRef)
{
Set<INamespaceDefinition> namespaceSet = qualifiers.getNamespaceSet();
if (isSuperRef)
namespaceSet = adjustNamespaceSetForSuper(def, namespaceSet);
return getPropertyFromDef((CompilerProject)project, def, name, namespaceSet, false);
}
/**
* Implementation for getPropertyFromDef + getQualifiedPropertyFromDef
*/
private IDefinition getPropertyFromDef(CompilerProject project, IDefinition def, String name, Set<INamespaceDefinition> namespaceSet, boolean lookForStatics)
{
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, namespaceSet);
return getPropertyFromDef(project, def, name, nsPred, nsPred, lookForStatics);
}
/**
* Implementation of getPropertyFromDef + getQualifiedPropertyFromDef
*
* @param project project to resolve references in
* @param def The {@link IDefinition} to get the property from
* @param name The name to look for
* @param pred The {@link Predicate} to use to perform the lookup
* @param nsPred The {@link NamespaceSetPredicate} to use if the namespace set needs to be modified
* during lookup
* @param lookForStatics whether to find statics or not
*/
private IDefinition getPropertyFromDef(CompilerProject project,
IDefinition def,
String name,
Predicate<IDefinition> pred,
NamespaceSetPredicate nsPred,
boolean lookForStatics)
{
ASScope defScope = (ASScope)(def instanceof IScopedDefinition ? ((IScopedDefinition)def).getContainedScope() : null);
// TODO: eliminate lookForStatics flag from getPropertyFromDef methods
if (defScope instanceof TypeScope)
{
// Adjust scope if we are looking in a TypeScope
TypeScope ts = (TypeScope)defScope;
if (lookForStatics)
defScope = ts.getStaticScope();
else
defScope = ts.getInstanceScope();
}
if (defScope != null)
{
ArrayList<IDefinition> defs = new ArrayList<IDefinition>(1);
defScope.getPropertyForMemberAccess(project, new FilteredCollection<IDefinition>(pred, defs), name, nsPred, false);
return getSingleResult(project, defs);
}
return null;
}
/**
* Implementation of getPropertyForScopeChain.
*
* This method will filter results based on baseName only - any additional filtering
* should be done by the {@link Collection} passed in.
*
* @param project {@link CompilerProject} to resolve things in
* @param defs The {@link Collection} to add the results to
* @param baseName The name of the definition to find
* @param namespaceSet the {@link NamespaceSetPredicate} to use if the namespace set needs to be adjusted
* during lookup
*/
protected void getPropertyForScopeChain(CompilerProject project, Collection<IDefinition> defs, String baseName, NamespaceSetPredicate namespaceSet, boolean findAll)
{
getLocalProperty(project, defs, baseName, true);
}
/**
* This is called by {@link ASScopeCache} when there was a cache miss.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param namespaceSet Namespace set in which the qualifier of any found
* definition must found.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return One or more {@link IDefinition}'s matched by the namespace set
* and base name.
*/
public List<IDefinition> findProperty(CompilerProject project, String baseName, Set<INamespaceDefinition> namespaceSet, DependencyType dt)
{
return findProperty(project, baseName, namespaceSet, dt, false);
}
/**
* Version of findProperty that determine the results based on the namespace set passed in,
* along with any additional constraints passed in via the {@link Predicate}.
*
*
* @param project The {@link CompilerProject} to resolve things in
* @param baseName The name to find
* @param additional Any additional constraints on the lookup. This predicate will
* run before any namespace checking occurs.
* @param namespaceSet The Namespace set to use for the lookup
* @param dt The dependency type to introduce if this resolves to something from
* another compilation unit
* @return a List of IDefinition that matched the name, namespace set, and any
* additional constraints specified by the predicate.
*/
public List<IDefinition> findProperty(CompilerProject project,
String baseName,
Predicate<IDefinition> additional,
Set<INamespaceDefinition> namespaceSet,
DependencyType dt)
{
return findProperty(project, baseName, additional, namespaceSet, dt, false);
}
/**
* This is the core <code>findproperty()</code> method. It implements the
* equivalent of the <code>findprop</code> AVM instruction in Falcon.
* <p>
* The algorithm searches up the scope chain, starting with this scope, for
* definitions with the specified base name and namespace set.
* <p>
* After the file scope, the project scope is searched if necessary. If
* definitions are found in the project scope, a dependency is created on
* the compilation unit that produced them.
* <p>
* If the <code>findAll</code> parameter is <code>false</code>, the search
* stops with the first scope that has one or more matching definition; if
* it is <code>true</code>, the search continues to find all matching
* definitions in the entire chain, including the project scope.
*
* @param accumulator Collection to which definitions that match the
* namespace set and base name are added.
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param namespaceSet Namespace set in which the qualifier of any found
* definition must found.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @param findAll If true, then find all definitions that match the
* namespace set and base name, not just those from the first scope with a
* single match.
*/
public void findProperty(Collection<IDefinition> accumulator, CompilerProject project,
String baseName, Set<INamespaceDefinition> namespaceSet,
DependencyType dt, boolean findAll)
{
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, namespaceSet);
FilteredCollection<IDefinition> filteredCollection = new FilteredCollection<IDefinition>(nsPred, accumulator);
findProperty(filteredCollection, project, baseName, nsPred, dt, findAll);
}
/**
* This is the implementation of the various <code>findproperty()</code> methods. It implements the
* equivalent of the <code>findprop</code> AVM instruction in Falcon.
* <p>
* The algorithm searches up the scope chain, starting with this scope, for
* definitions with the specified base name.
* <p>
* If any additional constraints are required (e.g. filtering based on the namespace set), then
* callers should pass in an {@link ASScopeBase.FilteredCollection} as the accumulator that will implement those
* constraints. For the common case, the accumulator will be an {@link ASScopeBase.FilteredCollection}
* with a {@link NamespaceSetPredicate}.
* <p>
* After the file scope, the project scope is searched if necessary. If
* definitions are found in the project scope, a dependency is created on
* the compilation unit that produced them.
* <p>
* If the <code>findAll</code> parameter is <code>false</code>, the search
* stops with the first scope that has one or more matching definition; if
* it is <code>true</code>, the search continues to find all matching
* definitions in the entire chain, including the project scope.
*
* @param accumulator Collection to which definitions that match the
* base name are added.
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param nsPred The {@link NamespaceSetPredicate}, if one is being used, that the lookup
* can modify as it walks up the scope chain (necessary to handle protected correctly).
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @param findAll If true, then find all definitions that match the
* namespace set and base name, not just those from the first scope with a
* single match.
*/
protected void findProperty(Collection<IDefinition> accumulator, CompilerProject project,
String baseName, NamespaceSetPredicate nsPred,
DependencyType dt, boolean findAll)
{
assert accumulator.isEmpty() : "findProperty() should not be called with a non-empty collection";
assert baseName.indexOf('.') == -1 : "baseName must not be any sort of qname";
// Walk the scope chain starting with this scope.
// This loop may go as far as the file scope, whose containing scope is null.
// But it may break out early; lastSearchScope will keep track of how far it went.
ASScope lastSearchedScope = null;
for (ASScope currentScope = this; currentScope != null; currentScope = currentScope.getContainingScope())
{
// If we're not looking for all matching definitions,
// and we've already got some, stop walking.
if (!findAll && accumulator.size() != 0)
break;
// Search one scope for any definitions matching baseName and naamespaceSet.
currentScope.getPropertyForScopeChain(project, accumulator, baseName, nsPred, findAll);
// Keep track of the last scope that was searched.
lastSearchedScope = currentScope;
}
assert lastSearchedScope != null || accumulator.size() == 0 : "If accumulator is not empty, which searched scope added to it?";
// Determine whether we need to search the project scope.
boolean searchProjectScope = false;
// If we haven't found any matching definitions yet,
// we need to search the project scope.
if (accumulator.size() == 0)
searchProjectScope = true;
// If we're looking for all matching definitions,
// we need to search the project scope.
else if (findAll)
searchProjectScope = true;
// If the last scope we searched was a package scope or a file scope,
// we need to search the project scope because the project scope
// might have other definitions with the same name which should
// cause an ambiguity.
else if (lastSearchedScope instanceof PackageScope ||
lastSearchedScope instanceof ASFileScope)
{
searchProjectScope = true;
}
// Search the project scope if necessary.
if (searchProjectScope)
{
ASProjectScope projectScope = project.getScope();
projectScope.getPropertyForScopeChain(this, accumulator, baseName, nsPred.getNamespaceSet(), dt);
}
}
/**
* For each {@link IProtectedNamespaceDefinition} in the given
* {@code namespaceSet}, if it does not have a corresponding
* {@link IStaticProtectedNamespaceDefinition}, create one and add it to the
* {@code namespaceSet}.
*
* @param namespaceSet Namespace definitions. New items might be added.
* @return Updated namespace definitions.
*/
@SuppressWarnings("unused")
private static Set<INamespaceDefinition> addStaticProtectedNS(Set<INamespaceDefinition> namespaceSet)
{
if (namespaceSet == null)
return null;
// The keys are URI strings. The values are "protected" namespace definitions.
final Map<String, INamespaceDefinition.IStaticProtectedNamespaceDefinition> staticProtectedNamespaces =
new HashMap<String, INamespaceDefinition.IStaticProtectedNamespaceDefinition>();
final Set<INamespaceDefinition.IProtectedNamespaceDefinition> protectedNamespaces =
new HashSet<NamespaceDefinition.IProtectedNamespaceDefinition>();
for (final INamespaceDefinition namespace : namespaceSet)
{
if (namespace instanceof INamespaceDefinition.IStaticProtectedNamespaceDefinition)
{
final INamespaceDefinition.IStaticProtectedNamespaceDefinition staticProtectedNamespace =
(INamespaceDefinition.IStaticProtectedNamespaceDefinition)namespace;
staticProtectedNamespaces.put(
staticProtectedNamespace.getURI(),
staticProtectedNamespace);
}
else if (namespace instanceof INamespaceDefinition.IProtectedNamespaceDefinition)
{
protectedNamespaces.add((INamespaceDefinition.IProtectedNamespaceDefinition)namespace);
}
}
// Find all "protected" namespace definitions that don't have their
// corresponding "static protected" namespace definitions.
final Set<INamespaceDefinition.IStaticProtectedNamespaceDefinition> addedStaticProtectedNamespaces =
new HashSet<NamespaceDefinition.IStaticProtectedNamespaceDefinition>();
for (final INamespaceDefinition.IProtectedNamespaceDefinition protectedNamespace : protectedNamespaces)
{
if (!staticProtectedNamespaces.containsKey(protectedNamespace.getURI()))
{
addedStaticProtectedNamespaces.add(
NamespaceDefinition.createStaticProtectedNamespaceDefinition(
protectedNamespace.getURI()));
}
}
final Set<INamespaceDefinition> result;
if (addedStaticProtectedNamespaces.isEmpty())
{
result = namespaceSet;
}
else
{
result = new HashSet<INamespaceDefinition>();
result.addAll(addedStaticProtectedNamespaces);
result.addAll(namespaceSet);
}
return result;
}
/**
* This is the core findproperty method. This method implements the
* equivalent of the findprop AVM instruction in Falcon.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param namespaceSet Namespace set in which the qualifier of any found
* definition must found.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @param findAll If true, then find all definitons that match the namespace
* set and base name, not just those from the first scope with a single
* match.
* @return One or more {@link IDefinition}'s matched by the namespace set
* and base name.
*/
private List<IDefinition> findProperty(CompilerProject project, String baseName, Set<INamespaceDefinition> namespaceSet, DependencyType dt, boolean findAll)
{
ArrayList<IDefinition> defs = new ArrayList<IDefinition>(1);
findProperty(defs, project, baseName, namespaceSet, dt, findAll);
return defs;
}
/**
* Version of findProperty that determine the results based on the namespace set passed in,
* along with any additional constraints passed in via the {@link Predicate}.
*
*
* @param project The {@link CompilerProject} to resolve things in
* @param baseName The name to find
* @param additional Any additional constraints on the lookup. This predicate will
* run before any namespace checking occurs.
* @param namespaceSet The Namespace set to use for the lookup
* @param dt The dependency type to introduce if this resolves to something from
* another compilation unit
* @return a List of IDefinition that matched the name, namespace set, and any
* additional constraints specified by the predicate.
*/
private List<IDefinition> findProperty(CompilerProject project,
String baseName,
Predicate<IDefinition> additional,
Set<INamespaceDefinition> namespaceSet,
DependencyType dt,
boolean findAll)
{
ArrayList<IDefinition> defs = new ArrayList<IDefinition>(1);
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, namespaceSet);
Predicate<IDefinition> pred = Predicates.and(additional, nsPred);
FilteredCollection<IDefinition> filteredCollection = new FilteredCollection<IDefinition>(pred, defs);
findProperty(filteredCollection, project, baseName, nsPred, dt, findAll);
return defs;
}
/**
* Is this scope inside a with scope.
*
* @return true if this scope is nested in a with scope, or this scope is a
* with scope
*/
public boolean isInWith()
{
return inWith;
}
/**
* Get any containing with scope
*
* @return the ASScope that is the containing with scope, or null if there
* is no containing with scope
*/
ASScope getContainingWithScope()
{
ASScope scope = this;
while (scope != null)
{
if (scope instanceof WithScope)
return scope;
scope = scope.getContainingScope();
}
return scope;
}
/**
* IFilter the result of a findDefinition based on any containing with scopes
* and if the lookup is allowed to escape a with scope This method is used
* by findProperty, and findPropertyQualified to filter the results. By
* default, the lookup will look past the with scopes (this is what code
* model expects), so we will filter the results here, but only if we are in
* a with scope. With scopes are rare enough that the performance hit
* shouldn't be too bad, since we only do the filtering when we know we are
* in a with scope. If we are not in a with scope, or the lookup is allowed
* to escape the with block, then we immediately return the passed in
* definition.
*
* @param d the definition the lookup resolved to
* @param canEscapeWith true if the lookup can esape a with, false if it
* can't
* @return the definition to use as the result of the lookup
*/
IDefinition filterWith(IDefinition d, boolean canEscapeWith)
{
if (!inWith || canEscapeWith || d == null)
return d;
ASScope withScope = getContainingWithScope();
if (withScope != null)
{
ASScope scope = this;
while (scope != null)
{
// Didn't find the defns containing scope before we hit
// the with, so act as if we couldn't resolve it.
if (scope == withScope)
return null;
// We found the declaring scope, and we haven't seen a with
// scope yet, so we can return the definition
if (scope == d.getContainingScope())
return d;
scope = scope.getContainingScope();
}
return null;
}
return d;
}
/**
* The main public entry point for the findprop operation in the compiler.
* This method uses the {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return A single {@link IDefinition} to which the specified base name
* resolves to in this scope, or null. Null is returned when no definition
* is found <b>and</b> when more than one definition is found.
*/
public IDefinition findProperty(ICompilerProject project, String baseName, DependencyType dt)
{
return findProperty(project, baseName, dt, false);
}
/**
* The main public entry point for the findprop operation in the compiler.
* This method uses the {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @param canEscapeWith should this lookup find definitions that occur
* outside of a containing with scope
* @return A single {@link IDefinition} to which the specified base name
* resolves to in this scope, or null. Null is returned when no definition
* is found <b>and</b> when more than one definition is found.
*/
public IDefinition findProperty(ICompilerProject project, String baseName, DependencyType dt, boolean canEscapeWith)
{
if (canDelegateLookupToContainingScope(baseName))
{
// If we know that we can't possibly find the property in this scope, just ask the containing scope
// which may have already computed and cached the result.
return getContainingScope().findProperty(project, baseName, dt, canEscapeWith);
}
assert baseName.indexOf('.') == -1 : "baseName must not be any sort of qname";
CompilerProject compilerProject = (CompilerProject)project;
ASScopeCache scopeCache = compilerProject.getCacheForScope(this);
return filterWith(scopeCache.findProperty(baseName, dt), canEscapeWith);
}
/**
* An alternate entry point for findprop operations.
*
* This method takes an addition Predicate that allows custom filtering of the results, instead
* of just using the namespace set. This method will still use the namespace set, but the predicate passed
* in will be called first to filter the results.
*
* @param project the active project
* @param baseName base name of the property we're looking for
* @param additional A Predicate that performs custom filtering on the results
* @param dt The dependency type that should be added to the dependency graph
* when resolving this reference across a compilation boundary
* @param canEscapeWith should this lookup find definitions that occur outside of a containing with scope
* @return A single {@link IDefinition} to which the specified base name resolves to in this
* scope, given the additional constraints supplied by the additional Predicate.
*/
public IDefinition findProperty(ICompilerProject project, String baseName, Predicate<IDefinition> additional, DependencyType dt, boolean canEscapeWith)
{
Set<INamespaceDefinition> nsSet = getNamespaceSetForName(project, baseName);
return findProperty(project, baseName, additional, nsSet, dt, canEscapeWith);
}
public IDefinition findProperty (ICompilerProject project, String baseName, Predicate<IDefinition> additional, Set<INamespaceDefinition> nsSet, DependencyType dt, boolean canEscapeWith)
{
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, nsSet);
List<IDefinition> storage = new ArrayList<IDefinition>();
Predicate<IDefinition> pred = Predicates.and(additional, nsPred);
FilteredCollection<IDefinition> defs = new FilteredCollection<IDefinition>(pred, storage);
findProperty(defs, (CompilerProject)project, baseName, nsPred, dt, false);
IDefinition def = null;
def = getSingleResult(project, storage);
return filterWith(def, canEscapeWith);
}
/**
* Helper method to narrow a List of results down to one result for the methods
* that return only 1 result.
* @return null if there are no results,
* the first definition if there is 1 result
* one of the definitions if there are multiple results, and the ambiguities can be resolved
* an {@link AmbiguousDefinition} if there are multiple results and the ambiguities could
* not be resolved
*/
static IDefinition getSingleResult (ICompilerProject project, List<IDefinition> defs)
{
IDefinition def;
switch (defs.size())
{
case 0:
// No definition found!
def = null;
break;
case 1:
// found single definition!
def = defs.get(0);
assert def.isInProject(project);
break;
default:
IDefinition d = AmbiguousDefinition.resolveAmbiguities(project, defs);
if (d != null)
def = d;
else
def = AmbiguousDefinition.get();
}
return def;
}
/**
* Is it ok to skip this scope, and just ask the containing scope to perform
* the lookup. This is possible if this scope does not contribute to the set
* of open namespaces, and if we have no definitions with the simple name we
* are looking for.
*
* @return true if we can just ask the containing scope to perform the
* lookup
*/
protected boolean canDelegateLookupToContainingScope(String name)
{
return namespaceSetSameAsContainingScopeNamespaceSet()
&& getContainingScope() != null
&& getLocalDefinitionSetByName(name) == null;
}
/**
* The main public entry point for the findprop operation in the compiler
* with an explicit qualifier namespace. This method uses the
* {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param qual {@link INamespaceDefinition} which must match the qualifier
* namespace of the found {@link IDefinition}.
* @param baseName base name of the property we are looking for.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return A single {@link IDefinition} to which the specified qualifier and
* base name resolves to in this scope, or null. Null is returned when no
* definition is found <b>and</b> when more than one definition is found.
*/
public IDefinition findPropertyQualified(ICompilerProject project, INamespaceDefinition qual, String baseName, DependencyType dt)
{
return findPropertyQualified(project, qual, baseName, dt, false);
}
/**
* The main public entry point for the findprop operation in the compiler
* with an explicit qualifier namespace. This method uses the
* {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param qual {@link INamespaceDefinition} which must match the qualifier
* namespace of the found {@link IDefinition}.
* @param baseName base name of the property we are looking for.
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return A single {@link IDefinition} to which the specified qualifier and
* base name resolves to in this scope, or null. Null is returned when no
* definition is found <b>and</b> when more than one definition is found.
*/
public IDefinition findPropertyQualified(ICompilerProject project, Predicate<IDefinition> additional,
INamespaceDefinition qual, String baseName, DependencyType dt)
{
if( qual == null )
return null;
NamespaceSetPredicate nsPred = new NamespaceSetPredicate(project, ImmutableSet.of(qual));
Predicate<IDefinition> pred = Predicates.and(additional, nsPred);
List<IDefinition> defs = new ArrayList<IDefinition>();
FilteredCollection<IDefinition> filteredCollection = new FilteredCollection<IDefinition>(pred, defs);
findProperty(filteredCollection, (CompilerProject)project, baseName, nsPred, dt, false);
return getSingleResult(project, defs);
}
/**
* The main public entry point for the findprop operation in the compiler
* with an explicit qualifier namespace. This method uses the
* {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param qual The qualifier(s) to use to lookup the property.
* @param baseName base name of the property we are looking for.
* @param canEscapeWith should this lookup find definitions that occur
* outside of a containing with scope
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return A single {@link IDefinition} to which the specified qualifier and
* base name resolves to in this scope, or null. Null is returned when no
* definition is found <b>and</b> when more than one definition is found.
*/
public IDefinition findPropertyQualified(ICompilerProject project, INamespaceDefinition qual, String baseName, DependencyType dt, boolean canEscapeWith)
{
assert baseName.indexOf('.') == -1 : "baseName must not be any sort of qname";
// Can't find a property if we don't know what its qualifier is
if( qual == null )
return null;
CompilerProject compilerProject = (CompilerProject)project;
ASScopeCache scopeCache = compilerProject.getCacheForScope(this);
IDefinition definition = scopeCache.findPropertyQualified(qual, baseName, dt);
return filterWith(definition, canEscapeWith);
}
/**
* The main public entry point for the findprop operation in the compiler
* with an explicit set of qualifier namespaces. This method uses the
* {@link ASScopeCache} to improve performance.
*
* @param project {@link ICompilerProject} whose symbol table is used to
* resolve namespace references in the "use namespace" set this scope.
* @param baseName base name of the property we are looking for.
* @param qual The qualifier(s) to use to lookup the property.
* @param canEscapeWith should this lookup find definitions that occur
* outside of a containing with scope
* @param dt The type of dependency that should be added to the dependency
* graph when resolving this reference across a compilation unit boundary.
* @return A single {@link IDefinition} to which the specified qualifier and
* base name resolves to in this scope, or null. Null is returned when no
* definition is found <b>and</b> when more than one definition is found.
*/
public IDefinition findPropertyQualified(ICompilerProject project, IQualifiers qual, String baseName, DependencyType dt, boolean canEscapeWith)
{
if( qual == null || qual.getNamespaceCount() == 0 )
return null ;
if( qual.getNamespaceCount() == 1 )
{
return findPropertyQualified(project, qual.getFirst(), baseName, dt, canEscapeWith);
}
else
{
List<IDefinition> defs = findProperty((CompilerProject)project, baseName, qual.getNamespaceSet(), dt);
return filterWith(getSingleResult(project, defs), canEscapeWith);
}
}
/**
* Helper method to get the namespace set to use for a super reference. This
* will replace the protected namespace for this class with the protected
* namespace for the super class in the returned namespace set.
*
* @param project project used to resolve namespaces
* @param superDef the IDefinition representing the base class
* @return The correct namespace set to use for a super reference
*/
public Set<INamespaceDefinition> getNamespaceSetForSuper(ICompilerProject project, IDefinition superDef)
{
Set<INamespaceDefinition> nsSet = getNamespaceSet(project);
return adjustNamespaceSetForSuper(superDef, nsSet);
}
/**
* Adjust the namespace set passed in so it's the right set for a super
* access. This will replace the protected namespace for this class with the
* protected namespace for the super class in the returned namespace set.
*
* @param superDef the IDefinition representing the base class
* @param nsSet the namespace set to adjust
* @return The correct namespace set to use for a super reference
*/
public Set<INamespaceDefinition> adjustNamespaceSetForSuper(IDefinition superDef, Set<INamespaceDefinition> nsSet)
{
ClassDefinitionBase containingClass = getContainingClass();
if (superDef instanceof ClassDefinition &&
nsSet.contains(containingClass.getProtectedNamespaceReference()))
{
Set<INamespaceDefinition> adjustedSet = new LinkedHashSet<INamespaceDefinition>();
adjustedSet.addAll(nsSet);
adjustedSet.remove(containingClass.getProtectedNamespaceReference());
adjustedSet.add(((ClassDefinition)superDef).getProtectedNamespaceReference());
return adjustedSet;
}
return nsSet;
}
/**
* Helper method to return the ClassDefinition this scope is inside of, if
* there is one.
*
* @return the ClassDefinition that contains this scope, or null if this
* scope is not in a ClassDefinition
*/
public ClassDefinitionBase getContainingClass()
{
ASScope scope = this;
ScopedDefinitionBase sdb = null;
while (scope != null && sdb == null)
{
// Walk up the scope chain until we find the first scope with a definition.
// stuff like catch, or with scopes will have no definition associated with them
sdb = scope.getDefinition();
scope = scope.getContainingScope();
}
if (sdb instanceof ClassDefinitionBase)
return (ClassDefinitionBase)sdb;
else if (sdb != null)
return (ClassDefinitionBase)sdb.getAncestorOfType(ClassDefinitionBase.class);
return null;
}
public ASFileScope getFileScope()
{
ASScope scope = this;
while (!(scope instanceof ASFileScope))
{
scope = scope.getContainingScope();
// instantiated Vectors may not have containing scopes
if (scope == null)
break;
}
return (ASFileScope)scope;
}
/**
* Get's the {@link IWorkspace} in which this {@link ASScope} lives.
*
* @return The {@link IWorkspace} in which this {@link ASScope} lives.
*/
public IWorkspace getWorkspace()
{
return getFileScope().getWorkspace();
}
public String getContainingSourcePath(String qName, ICompilerProject project)
{
ASScope containingScope = getContainingScope();
if (containingScope != null)
return containingScope.getContainingSourcePath(qName, project);
return null;
}
/**
* Determine if any of the definitions in this scope are Bindable
*
* @return true, if any definitions in this scope are explicitly marked
* bindable, false if there are none.
*/
public boolean hasAnyBindableDefinitions()
{
for (IDefinitionSet set : getAllLocalDefinitionSets())
{
int n = set.getSize();
for (int i = 0; i < n; i++)
{
IDefinition d = set.getDefinition(i);
if (d.isBindable())
return true;
}
}
return false;
}
/**
* Get's the {@link ScopedDefinitionBase} that contains this scope. This
* method differs from {@link #getDefinition()} in that this method will
* walk up the scope chain.
*
* @return The {@link ScopedDefinitionBase} that contains this scope
*/
public IScopedDefinition getContainingDefinition()
{
// sub-classes override this method.
// This class just returns the definition attached this scope.
return containingDefinition;
}
/**
* Makes this scope be the containing scope of the specified anonymous
* function. Anonymous functions do not get added to scopes, but they do
* need to know which scope they are inside of.
*/
public void setAsContainingScopeOfAnonymousFunction(FunctionDefinition anonymousFunction)
{
anonymousFunction.setContainingScope(this);
}
/**
* Add a dependency to the given builtintype, from the compilation unit which contains this scope
* @param project the active project
* @param builtinType the builtin type to depend on
* @param dependencyType the type of dependency to add
*/
public void addDependencyOnBuiltinType(ICompilerProject project, IASLanguageConstants.BuiltinType builtinType,
DependencyType dependencyType)
{
// Just proxy up to the file scope, since dependencies are from CompilationUnit to CompilationUnit
if( containingScope != null )
containingScope.addDependencyOnBuiltinType(project, builtinType, dependencyType);
}
/**
* Implementation of addDependencyOnBuiltinType that will actually add the dependency.
* This will only be called if there is a cache miss.
* @param project the active project
* @param builtinType the builtin type to depend on
* @param dependencyType type of dependency to add
*/
void addDependencyOnBuiltinTypeImpl(CompilerProject project, IASLanguageConstants.BuiltinType builtinType,
DependencyType dependencyType)
{
IDefinition definition = project.getBuiltinType(builtinType);
if( definition != null &&
builtinType != IASLanguageConstants.BuiltinType.ANY_TYPE &&
builtinType != IASLanguageConstants.BuiltinType.VOID)
{
ASProjectScope projectScope = project.getScope();
ICompilationUnit from = projectScope.getCompilationUnitForScope(this);
ICompilationUnit to = projectScope.getCompilationUnitForDefinition(definition);
String qname = definition.getQualifiedName();
project.addDependency(from, to, dependencyType, qname);
}
}
}