/*
*
* 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.definitions;
import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import org.apache.flex.compiler.common.DependencyType;
import org.apache.flex.compiler.common.RecursionGuard;
import org.apache.flex.compiler.constants.IASLanguageConstants;
import org.apache.flex.compiler.constants.IMetaAttributeConstants;
import org.apache.flex.compiler.definitions.IClassDefinition;
import org.apache.flex.compiler.definitions.IDefinition;
import org.apache.flex.compiler.definitions.IInterfaceDefinition;
import org.apache.flex.compiler.definitions.ITypeDefinition;
import org.apache.flex.compiler.definitions.metadata.IMetaTag;
import org.apache.flex.compiler.definitions.references.IReference;
import org.apache.flex.compiler.internal.projects.CompilerProject;
import org.apache.flex.compiler.internal.scopes.ASProjectScope;
import org.apache.flex.compiler.internal.scopes.ASScope;
import org.apache.flex.compiler.internal.scopes.ASScopeCache;
import org.apache.flex.compiler.internal.scopes.TypeScope;
import org.apache.flex.compiler.internal.semantics.SemanticUtils;
import org.apache.flex.compiler.internal.tree.as.ClassNode;
import org.apache.flex.compiler.problems.AmbiguousReferenceProblem;
import org.apache.flex.compiler.problems.DuplicateInterfaceProblem;
import org.apache.flex.compiler.problems.ICompilerProblem;
import org.apache.flex.compiler.problems.UnknownInterfaceProblem;
import org.apache.flex.compiler.projects.ICompilerProject;
import org.apache.flex.compiler.scopes.IDefinitionSet;
import org.apache.flex.compiler.tree.as.IASNode;
import org.apache.flex.compiler.tree.as.IExpressionNode;
import org.apache.flex.compiler.tree.as.ITypeNode;
import org.apache.flex.utils.Version;
import com.google.common.collect.Iterables;
public abstract class ClassDefinitionBase extends TypeDefinitionBase implements IClassDefinition
{
protected ClassDefinitionBase(String name)
{
super(name);
alternatives = null;
}
@Override
public IClassDefinition[] resolveAncestry(ICompilerProject project)
{
return Iterables.toArray(classIterable(project, true), IClassDefinition.class);
}
/**
* Resolve one of the implemented interfaces.
*
* @param project {@link ICompilerProject} whose symbol table should be used
* to resolve references.
* @param i Index indicating which implemented interface to resolve.
* @return {@link IInterfaceDefinition} for the implemented interface if the
* reference can be resolved, null otherwise.
*/
public InterfaceDefinition resolveImplementedInterface(ICompilerProject project, int i)
{
IReference[] implementedInterfaces = getImplementedInterfaceReferences();
if ((implementedInterfaces != null) && (implementedInterfaces.length > i))
{
ITypeDefinition typeDefinition = resolveType(implementedInterfaces[i], project, DependencyType.INHERITANCE);
if (typeDefinition instanceof IInterfaceDefinition)
return (InterfaceDefinition)typeDefinition;
}
return null;
}
@Override
public IInterfaceDefinition[] resolveImplementedInterfaces(ICompilerProject project)
{
if( this.getImplementedInterfaceReferences().length > 0 )
return ((CompilerProject)project).getCacheForScope(getContainedScope()).resolveInterfaces();
return new IInterfaceDefinition[0];
}
/**
* Resolve the implemented interfaces of this Class
* @param project the active project
* @return An array of all the interfaces this class implements
*/
public IInterfaceDefinition[] resolveInterfacesImpl (ICompilerProject project)
{
IInterfaceDefinition[] implementedInterfaces =
resolveImplementedInterfaces(project, (Collection<ICompilerProblem>)null);
// Don't return null elements for interfaces that can't be resolved.
return filterNullInterfaces(implementedInterfaces);
}
/**
* Version of resolveImplementedInterfaces that will log Problems associated
* with resolving the implemented interfaces This will not log any problems
* if null is passed in for the problem collection.
*
* @param project project to resolve the interfaces in
* @param problems a Collection to add problems to if any are encountered,
* or null if the caller is not interested in the problems.
* @return Array of InterfaceDefinitions which are the interfaces
* implemented by this class in the given project
*/
public InterfaceDefinition[] resolveImplementedInterfaces(ICompilerProject project, Collection<ICompilerProblem> problems)
{
return resolveImplementedInterfaces(project, problems, true);
}
/**
* Version of resolveImplementedInterfaces that will log Problems associated
* with resolving the implemented interfaces This will not log any problems
* if null is passed in for the problem collection. This method will also
* find, or not find, implicit implemented interfaces, depending on the
* value of the includeImplicit flag. Implicit interfaces are things like
* IEventDispatcher when a Class is marked [Bindable] - the user does not
* need to explicitly implement IEventDispatcher, but the compiler must act
* as if the interface was implemented.
*
* @param project project to resolve the interfaces in
* @param problems a Collection to add problems to if any are encountered,
* or null if the caller is not interested in the problems.
* @param includeImplicits true, if implicit interfaces should be found,
* false, if they should not be found.
* @return Array of InterfaceDefinitions which are the interfaces
* implemented by this class in the given project
*/
public InterfaceDefinition[] resolveImplementedInterfaces(ICompilerProject project, Collection<ICompilerProblem> problems, boolean includeImplicits)
{
IReference[] implementedInterfaces = getImplementedInterfaceReferences();
if (implementedInterfaces != null)
{
int n = implementedInterfaces.length;
InterfaceDefinition[] result = new InterfaceDefinition[n];
Set<InterfaceDefinition> seenInterfaces = null;
if (problems != null)
{
seenInterfaces = new HashSet<InterfaceDefinition>();
}
for (int i = 0; i < n; i++)
{
IReference implementedInterface = implementedInterfaces[i];
ITypeDefinition typeDefinition =
resolveType(implementedInterface, project, DependencyType.INHERITANCE);
if (!(typeDefinition instanceof InterfaceDefinition))
{
IDefinition idef = null;
if (typeDefinition == null)
{
idef = implementedInterface.resolve(project, (ASScope)this.getContainingASScope(), DependencyType.INHERITANCE, true);
}
if (problems != null)
{
if (idef instanceof AmbiguousDefinition)
problems.add(new AmbiguousReferenceProblem(getNode(), implementedInterface.getDisplayString()));
else
problems.add(unknownInterfaceProblem(implementedInterface, i));
}
typeDefinition = null;
}
else if (seenInterfaces != null)
{
if (seenInterfaces.contains(typeDefinition))
{
if (problems != null)
problems.add(duplicateInterfaceProblem(implementedInterface, i));
}
seenInterfaces.add((InterfaceDefinition)typeDefinition);
}
if (problems != null)
{
// Report a problem if the interface is deprecated
// and the reference to it is not within a deprecated API.
if (typeDefinition != null && typeDefinition.isDeprecated())
{
IASNode node = getInterfaceNode(i);
if (!SemanticUtils.hasDeprecatedAncestor(node))
{
ICompilerProblem problem = SemanticUtils.createDeprecationProblem(typeDefinition, node);
problems.add(problem);
}
}
}
result[i] = (InterfaceDefinition)typeDefinition;
}
if (includeImplicits)
{
if (needsEventDispatcher(project))
{
ITypeDefinition iEventDispatcher = resolveType(IASLanguageConstants.IEventDispatcher, project, null);
if (iEventDispatcher instanceof InterfaceDefinition)
{
InterfaceDefinition[] newResult = new InterfaceDefinition[result.length + 1];
System.arraycopy(result, 0, newResult, 0, result.length);
newResult[result.length] = (InterfaceDefinition)iEventDispatcher;
result = newResult;
}
}
}
return result;
}
return new InterfaceDefinition[0];
}
/**
* Determine if this class needs to add an implicit 'implements
* flash.events.IEventDispatcher' due to the class, or some of its members
* being marked bindable. If this class is marked bindable, or if it has
* members that are marked bindable then this class will need to implement
* IEventDispatcher if no baseclass already implements IEventDispatcher, and
* no implemented interface extends IEventDispatcher.
* <p>
* The result of this method is cached in the {@link ASScopeCache} for the
* {@link TypeScope} contained by this class.
*
* @param project The project to use to resolve interfaces and base classes
* @return true if this class needs to add IEventDispatcher to its interface
* list, and should implement the IEventDispatcher methods.
*/
public boolean needsEventDispatcher(ICompilerProject project)
{
if (isImplicit())
return false;
return ((CompilerProject)project).getCacheForScope(getContainedScope()).needsEventDispatcher();
}
/**
* Determine if this class needs to add an implicit 'implements
* flash.events.IEventDispatcher' due to the class, or some of its members
* being marked bindable. If this class is marked bindable, or if it has
* members that are marked bindable then this class will need to implement
* IEventDispatcher if no baseclass already implements IEventDispatcher, and
* no implemented interface extends IEventDispatcher.
* <p>
* This method is called by the {@link ASScopeCache} and should not be
* called by other classes. All classes otehr than the {@link ASScopeCache}
* should call {@link #needsEventDispatcher(ICompilerProject)}.
*
* @param project The project to use to resolve interfaces and base classes
* @return true if this class needs to add IEventDispatcher to its interface
* list, and should implement the IEventDispatcher methods.
*/
public boolean computeNeedsEventDispatcher(ICompilerProject project)
{
if (isBindable() || getContainedScope().hasAnyBindableDefinitions())
{
ITypeDefinition iEventDispatcher = resolveType(IASLanguageConstants.IEventDispatcher, project, null);
if (iEventDispatcher != null)
{
IClassDefinition baseClass = resolveBaseClass(project);
if (baseClass != null)
{
if (baseClass.isInstanceOf(iEventDispatcher, project))
{
// The base class already implements IEventDispatcher, so we don't need to implement
// it here
return false;
}
}
InterfaceDefinition[] interfs = resolveImplementedInterfaces(project, null, false);
for (InterfaceDefinition interf : interfs)
{
if (interf != null && interf.isInstanceOf(iEventDispatcher, project))
return false;
}
// None of the base classes implement IEventDispatcher (either implicitly or explicitly)
// and this class does not explicitly implement IEventDispatcher
return true;
}
}
return false;
}
/**
* Determine if this class needs a static event dispatcher added to it. This
* is neccessary if it has any static properties that are bindable.
*
* @param project Project to use to resolve things.
* @return true, if we need to codegen a static event dispatcher method
*/
public boolean needsStaticEventDispatcher(ICompilerProject project)
{
boolean isBindable = isBindable();
Collection<IDefinitionSet> defs = getContainedScope().getAllLocalDefinitionSets();
for (IDefinitionSet set : defs)
{
for (int i = 0, l = set.getSize(); i < l; ++i)
{
IDefinition d = set.getDefinition(i);
if (isBindable && d.isStatic())
return true;
else if (d.isStatic() && d.isBindable())
return true;
}
}
return false;
}
/**
* Helper method to generate an UnknownInterfaceProblem - will use the Node
* for the implemented interfaces, if there is one, for location info,
* therwise will use the definition for location info
*/
private UnknownInterfaceProblem unknownInterfaceProblem(IReference interfRef, int idx)
{
IASNode node = getInterfaceNode(idx);
if (node != null)
return new UnknownInterfaceProblem(node, interfRef.getDisplayString());
else
return new UnknownInterfaceProblem(this, interfRef.getDisplayString());
}
/**
* Helper method to generate an DuplicateInterfaceProblem - will use the
* Node for the implemented interfaces, if there is one, for location info,
* therwise will use the definition for location info
*/
private DuplicateInterfaceProblem duplicateInterfaceProblem(IReference interfRef, int idx)
{
IASNode node = getInterfaceNode(idx);
if (node != null)
return new DuplicateInterfaceProblem(node, getBaseName(), interfRef.getDisplayString());
else
return new DuplicateInterfaceProblem(this, getBaseName(), interfRef.getDisplayString());
}
/**
* Get the IASNode for the implemented interface at index i - used for error
* reporting
*
* @param i the Index of the interface you want the node for
* @return the IASNode representing the interface in the implements clause,
* or the Node for this class if the interface node can't be determined (at
* least the error will then point at the right class).
*/
private IASNode getInterfaceNode(int i)
{
ITypeNode typeNode = this.getNode();
IASNode site = typeNode;
if (typeNode instanceof ClassNode)
{
ClassNode clsNode = (ClassNode)typeNode;
IExpressionNode interfs[] = clsNode.getImplementedInterfaceNodes();
site = interfs[i];
}
return site;
}
public Iterable<IClassDefinition> classIterable(final ICompilerProject project, final boolean includeThis)
{
final ClassDefinitionBase initialClass = this;
return new Iterable<IClassDefinition>()
{
@Override
public Iterator<IClassDefinition> iterator()
{
return initialClass.classIterator(project, includeThis);
}
};
}
@Override
public IClassIterator classIterator(ICompilerProject project, boolean includeThis)
{
return new ClassIterator(this, project, includeThis);
}
@Override
public Iterator<IInterfaceDefinition> interfaceIterator(ICompilerProject project)
{
return new InterfaceDefinition.InterfaceIterator(this, project, null);
}
@Override
public boolean isInstanceOf(final ITypeDefinition type, ICompilerProject project)
{
// A class is considered an instance of itself.
if (type == this)
return true;
if (type instanceof IClassDefinition)
{
// We're trying to determine whether this class
// is derived from a specified class ('type').
// Iterate the superclass chain looking for 'type'.
Iterator<IClassDefinition> iter = classIterator(project, false);
while (iter.hasNext())
{
IClassDefinition cls = iter.next();
if (cls == type)
return true;
}
return false;
}
else if (type instanceof IInterfaceDefinition)
{
// We're trying to determine whether this class
// implements a specified interface ('type').
// Iterate all of the interfaces that this class implements,
// looking for 'type'.
Iterator<IInterfaceDefinition> iter = interfaceIterator(project);
while (iter.hasNext())
{
IInterfaceDefinition intf = iter.next();
if (intf == type)
return true;
}
return false;
}
return false;
}
@Override
public Set<IInterfaceDefinition> resolveAllInterfaces(ICompilerProject project)
{
Set<IInterfaceDefinition> interfaces = new HashSet<IInterfaceDefinition>();
Iterator<IInterfaceDefinition> iter = interfaceIterator(project);
while (iter.hasNext())
{
IInterfaceDefinition intf = iter.next();
interfaces.add(intf);
}
return interfaces;
}
/*
* This inner class implements an iterator that enumerates all of this
* ClassDefinition's superclasses. <p> It will stop iterating when it
* detects a loop in the superclass chain; at that point,
* <code>foundLoop()</code> will return <code>true</code>.
*/
public static class ClassIterator implements IClassIterator
{
public ClassIterator(IClassDefinition thisClass, ICompilerProject project, boolean includeThis)
{
assert thisClass != null;
assert project != null;
this.project = project;
nextClass = includeThis ? thisClass : thisClass.resolveBaseClass(project);
guard = new RecursionGuard(nextClass);
foundLoop = false;
}
private ICompilerProject project;
private IClassDefinition nextClass;
private RecursionGuard guard;
private boolean foundLoop;
@Override
public boolean hasNext()
{
return nextClass != null;
}
@Override
public IClassDefinition next()
{
if (!hasNext())
throw new NoSuchElementException();
IClassDefinition next = nextClass;
nextClass = nextClass.resolveBaseClass(project);
// The RecursionGuard will detect a loop in the superclass chain.
if (guard.isLoop(nextClass))
{
foundLoop = true;
nextClass = null;
}
return next;
}
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
@Override
public boolean foundLoop()
{
return foundLoop;
}
}
/**
* Represents the information in
* [Alternative(replacement="...", since"...")] metadata.
*/
private static final class AlternativeInformation
{
/**
* Constructor.
*/
public AlternativeInformation(String replacement, Version sinceVersion)
{
this.replacement = replacement;
this.sinceVersion = sinceVersion;
}
private String replacement;
private Version sinceVersion;
/**
* @return the replacement
*/
public String getReplacement()
{
return replacement;
}
/**
* @return the 'since' version
*/
public Version getSinceVersion()
{
return sinceVersion;
}
}
private SoftReference<AlternativeInformation[]> alternatives;
private AlternativeInformation[] getAlternatives()
{
AlternativeInformation[] result = null;
if (alternatives != null)
result = alternatives.get();
if (result != null)
return result;
result = buildAlternatives();
alternatives = new SoftReference<AlternativeInformation[]>(result);
return result;
}
private AlternativeInformation[] buildAlternatives()
{
IMetaTag[] metaTags = getMetaTagsByName(IMetaAttributeConstants.ATTRIBUTE_ALTERNATIVE);
if (metaTags == null || metaTags.length == 0)
return new AlternativeInformation[0];
List<AlternativeInformation> result = new LinkedList<AlternativeInformation>();
for (IMetaTag metaTag : metaTags)
{
String replacement = metaTag.getAttributeValue(IMetaAttributeConstants.NAME_ALTERNATIVE_REPLACEMENT);
if (replacement == null || replacement.isEmpty())
continue;
if (replacement.compareTo(IMetaAttributeConstants.VALUE_INSPECTABLE_ENVIRONMENT_NONE) == 0)
continue;
String sinceString = metaTag.getAttributeValue(IMetaAttributeConstants.NAME_ALTERNATIVE_SINCE);
Version sinceVersion = null;
if (sinceString != null)
{
try
{
sinceVersion = new Version(sinceString);
}
catch (Exception e)
{
continue;
}
}
result.add(new AlternativeInformation(replacement, sinceVersion));
}
return result.toArray(new AlternativeInformation[result.size()]);
}
@Override
public IClassDefinition[] getAlternativeClasses(ICompilerProject project, Version version)
{
AlternativeInformation[] alternatives = getAlternatives();
List<IClassDefinition> result = new ArrayList<IClassDefinition>(alternatives.length);
ASProjectScope projectScope = (ASProjectScope)project.getScope();
for (AlternativeInformation alternative : alternatives)
{
Version alternativeSinceVersion = alternative.getSinceVersion();
if (alternativeSinceVersion.compareBugFixVersionTo(version) >= 0)
{
String replacement = alternative.getReplacement();
IDefinition def = projectScope.findDefinitionByName(replacement);
// replacements should only point to classes, so ignore anything which
// isn't a class
if (!(def instanceof IClassDefinition))
continue;
result.add((IClassDefinition)def);
}
}
return result.toArray(new IClassDefinition[result.size()]);
}
@Override
public IMetaTag[] findMetaTagsByName(String name, ICompilerProject project)
{
if (IMetaAttributeConstants.NON_INHERITING_METATAGS.contains(name))
return getMetaTagsByName(name);
List<IMetaTag> list = new ArrayList<IMetaTag>();
Iterator<IClassDefinition> classIterator = classIterator(project, true);
while (classIterator.hasNext())
{
IClassDefinition c = classIterator.next();
for (IMetaTag metaTag : c.getMetaTagsByName(name))
{
list.add(metaTag);
}
}
return list.toArray(new IMetaTag[0]);
}
@Override
public abstract IReference[] getImplementedInterfaceReferences();
@Override
public String getIconFile()
{
IMetaTag iconFileMetaTag = getMetaTagByName(IMetaAttributeConstants.ATTRIBUTE_ICON_FILE);
return iconFileMetaTag != null ? iconFileMetaTag.getValue() : null;
}
}