Java tutorial
/* * * 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.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.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)) { if (problems != null) 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; } }