protected void generateBindableImpl() {
if (classDefinition.needsEventDispatcher(classScope.getProject())) {
// Generate a EventDispatcher member, equivalent to:
// private var _bindingEventDispatcher : flash.events.EventDispatcher;
//
// Note that it is in a separate private namespace, so it won't conflict with user defined
// private members
// Add init code for the _bindingEventDispatcher to the ctor
// this is the equivalent of:
// _bindingEventDispatcher = new flash.events.EventDispatcher(this);
iinitInsns.addAll(BindableHelper.generateBindingEventDispatcherInit(itraits, false));
BindableHelper.generateAddEventListener(classScope);
BindableHelper.generateDispatchEvent(classScope);
BindableHelper.generateHasEventListener(classScope);
BindableHelper.generateRemoveEventListener(classScope);
BindableHelper.generateWillTrigger(classScope);
}
if (classDefinition.needsStaticEventDispatcher(classScope.getProject())) {
cinitInsns.addAll(BindableHelper.generateBindingEventDispatcherInit(ctraits, true));
BindableHelper.generateStaticEventDispatcherGetter(classStaticScope);
}
}
private void addAnyEmbeddedAsset() {
ICompilerProject project = classScope.getProject();
if (!(project instanceof CompilerProject)) return;
EmbedData embedData =
classDefinition.getEmbeddedAsset((CompilerProject) project, classScope.getProblems());
if (embedData != null) classScope.getGlobalScope().getEmbeds().add(embedData);
}
/**
* Check the class definition for various errors related to implemented interfaces, such as making
* sure that all interface methods are implemented
*
* @param cls the class definition to check
*/
void implementedInterfaceSemanticChecks(ClassDefinition cls) {
Iterator<IInterfaceDefinition> it = cls.interfaceIterator(classScope.getProject());
while (it.hasNext()) {
IInterfaceDefinition interf = it.next();
if (interf instanceof InterfaceDefinition) {
((InterfaceDefinition) interf)
.validateClassImplementsAllMethods(
classScope.getProject(), cls, classScope.getProblems());
}
}
}
protected void generateRequiredContingentDefinitions() {
List<IDefinition> definitons = classDefinition.getContingentDefinitions();
for (IDefinition definition : definitons) {
if (!definition.isContingentNeeded(classScope.getProject())) continue;
assert (definition instanceof VariableDefinition)
: "The code generator only supports contigent variable definitions";
final IDefinitionNode node = definition.getNode();
declareVariable(
(VariableNode) node,
(VariableDefinition) definition,
definition.isStatic(),
definition instanceof IConstantDefinition,
LexicalScope.noInitializer);
}
}
/** Finish the class' definition. */
void finishClassDefinition() {
// the generation of instructions for variable initialization is delayed
// until now, so we can add that initialization to the front of
// the cinit instruction list.
if (!staticVariableInitializers.isEmpty()) {
InstructionList exisitingCinitInsns = null;
if (!this.cinitInsns.isEmpty()) {
exisitingCinitInsns = new InstructionList();
exisitingCinitInsns.addAll(this.cinitInsns);
this.cinitInsns = new InstructionList();
}
for (VariableNode var : staticVariableInitializers) generateInstructions(var, true);
if (exisitingCinitInsns != null) this.cinitInsns.addAll(exisitingCinitInsns);
}
// add "goto_definition_help" metadata to user defined metadata.
ITraitVisitor tv =
classScope.getGlobalScope().traitsVisitor.visitClassTrait(TRAIT_Class, className, 0, cinfo);
IMetaInfo[] metaTags = getAllMetaTags(classDefinition);
// Add "goto definition help" metadata for the constructor.
if (this.ctorFunction != null) {
FunctionDefinition ctorDef = this.ctorFunction.getDefinition();
MetaTag metaTag =
MetaTag.createGotoDefinitionHelp(
classDefinition,
classDefinition.getContainingFilePath(),
Integer.toString(ctorDef.getNameStart()),
true);
if (metaTag != null) metaTags = MetaTag.addMetaTag(metaTags, metaTag);
}
this.classScope.processMetadata(tv, metaTags);
tv.visitEnd();
// Need to do this before generating the CTOR as the generated code may result in insns that
// need to be added to the ctor.
generateBindableImpl();
generateRequiredContingentDefinitions();
addAnyEmbeddedAsset();
// Make any vistEnd method calls
// that were deferred.
// callVisitEnds must be called on the same thread
// that started code generation. Since we don't generate
// classes in parallel yet, we know that we are on the thread
// that started code generation here.
classScope.callVisitEnds();
classStaticScope.callVisitEnds();
// Create the class' constructor function.
if (this.ctorFunction != null) {
MethodInfo mi =
classScope
.getGenerator()
.generateFunction(this.ctorFunction, classScope, this.iinitInsns);
if (mi != null) this.iinfo.iInit = mi;
} else if (!this.iinitInsns.isEmpty()) {
// Synthesize a constructor.
this.iinfo.iInit = new MethodInfo();
MethodBodyInfo iinit = new MethodBodyInfo();
iinit.setMethodInfo(this.iinfo.iInit);
IMethodVisitor mv = emitter.visitMethod(this.iinfo.iInit);
mv.visit();
IMethodBodyVisitor mbv = mv.visitBody(iinit);
InstructionList ctor_insns = new InstructionList();
ctor_insns.addInstruction(OP_getlocal0);
ctor_insns.addInstruction(OP_pushscope);
ctor_insns.addAll(this.iinitInsns);
// Call the superclass' constructor after the instance
// init instructions; this doesn't seem like an abstractly
// correct sequence, but it's what ASC does.
ctor_insns.addInstruction(OP_getlocal0);
ctor_insns.addInstruction(OP_constructsuper, 0);
ctor_insns.addInstruction(OP_returnvoid);
mbv.visit();
mbv.visitInstructionList(ctor_insns);
mbv.visitEnd();
mv.visitEnd();
}
// If the class has static initialization
// logic, emit a cinit routine.
if (!this.cinitInsns.isEmpty()) {
InstructionList cinit_insns = new InstructionList();
cinit_insns.addInstruction(OP_getlocal0);
cinit_insns.addInstruction(OP_pushscope);
// TODO: Examine other end-of-function processing
// and ensure it's completed.
this.classStaticScope.finishClassStaticInitializer(this.cinitInsns);
cinit_insns.addAll(this.cinitInsns);
cinit_insns.addInstruction(OP_returnvoid);
this.classStaticScope.methodBodyVisitor.visitInstructionList(cinit_insns);
this.classStaticScope.methodBodyVisitor.visitEnd();
this.classStaticScope.methodVisitor.visitEnd();
} else {
// Ensure nothing got dropped.
assert (this.classStaticScope.methodBodyVisitor == null);
}
itraits.visitEnd();
ctraits.visitEnd();
cv.visitEnd();
}
/**
* Constructor. Initializes the ClassDirectiveProcessor and its associated AET data structures.
*
* @param node - the AST that starts the class' definition in source; used for diagnostics.
* @param class_definition - the class' definition
* @param enclosing_scope - the immediately enclosing lexical scope.
* @param emitter - the active ABC emitter.
*/
ClassDirectiveProcessor(
ICommonClassNode node,
ClassDefinition class_definition,
LexicalScope enclosing_scope,
IABCVisitor emitter) {
super(enclosing_scope.getProblems());
this.emitter = emitter;
this.definitionSource = node;
assert (this.definitionSource != null) : "Class definition AST must be provided.";
this.classScope = enclosing_scope.pushFrame();
this.classStaticScope = enclosing_scope.pushFrame();
if (node.getNodeID() == ASTNodeID.ClassID) {
classScope.setInitialControlFlowRegionNode(((ClassNode) node).getScopedNode());
classStaticScope.setInitialControlFlowRegionNode(((ClassNode) node).getScopedNode());
}
ICompilerProject project = classScope.getProject();
// Set the class Name.
this.classDefinition = class_definition;
this.className = classDefinition.getMName(project);
iinfo.name = className;
// Check for a duplicate class name.
switch (SemanticUtils.getMultiDefinitionType(this.classDefinition, project)) {
case AMBIGUOUS:
classScope.addProblem(
new DuplicateClassDefinitionProblem(node, class_definition.getBaseName()));
break;
case NONE:
break;
default:
assert false; // I don't think classes can have other type of multiple definitions
}
if (node instanceof BaseDefinitionNode) // test doesn't work for MXML, which is OK.
{
BaseDefinitionNode n = (BaseDefinitionNode) node;
SemanticUtils.checkScopedToDefaultNamespaceProblem(classScope, n, classDefinition, null);
}
// Resolve the super class, checking that it exists,
// that it is a class rather than an interface,
// that it isn't final, and that it isn't the same as this class.
ClassDefinition superclassDefinition =
SemanticUtils.resolveBaseClass(node, class_definition, project, classScope.getProblems());
// Check that the superclass isn't a forward reference, but only need to do this if both
// definitions come from the same containing source. getContainingFilePath() returns the file
// from the ASFileScope, so no need to worry about included files.
if (!classDefinition.isGeneratedEmbedClass()
&& classDefinition
.getContainingFilePath()
.equals(superclassDefinition.getContainingFilePath())) {
// If the absolute offset in the class is less than the
// offset of the super class, it must be a forward reference in the file
int classOffset = classDefinition.getAbsoluteStart();
int superClassOffset = superclassDefinition.getAbsoluteEnd();
if (classOffset < superClassOffset)
classScope.addProblem(
new ForwardReferenceToBaseClassProblem(node, superclassDefinition.getQualifiedName()));
}
// Set the superclass Name.
this.superclassName = superclassDefinition.getMName(project);
iinfo.superName = superclassName;
// Resolve the interfaces.
IInterfaceDefinition[] interfaces =
classDefinition.resolveImplementedInterfaces(project, classScope.getProblems());
// Set the interface Names.
int n_interfaces = interfaces.length;
ArrayList<Name> interface_names = new ArrayList<Name>(n_interfaces);
for (int i = 0; i < n_interfaces; i++) {
InterfaceDefinition idef = (InterfaceDefinition) interfaces[i];
if (idef != null) {
Name interfaceName = ((InterfaceDefinition) interfaces[i]).getMName(project);
interface_names.add(interfaceName);
}
}
iinfo.interfaceNames = interface_names.toArray(new Name[interface_names.size()]);
// Set the flags corresponding to 'final' and 'dynamic'.
if (classDefinition.isFinal()) iinfo.flags |= ABCConstants.CLASS_FLAG_final;
if (!classDefinition.isDynamic()) iinfo.flags |= ABCConstants.CLASS_FLAG_sealed;
iinfo.protectedNs =
((NamespaceDefinition) classDefinition.getProtectedNamespaceReference()).getAETNamespace();
this.cv = emitter.visitClass(iinfo, cinfo);
cv.visit();
this.itraits = cv.visitInstanceTraits();
this.ctraits = cv.visitClassTraits();
this.classScope.traitsVisitor = this.itraits;
this.classStaticScope.traitsVisitor = this.ctraits;
// Build an array of the names of all the ancestor classes.
ArrayList<Name> ancestorClassNames = new ArrayList<Name>();
// Walk the superclass chain, starting with this class
// and (unless there are problems) ending with Object.
// This will accomplish three things:
// - find loops;
// - build the array of names of ancestor classes;
// - set the needsProtected flag if this class or any of its ancestor classes needs it.
boolean needsProtected = false;
// Remember the most recently examined class in case there's a cycle in the superclass
// chain, in which case we'll need it to issue a diagnostic.
ClassDefinition c = null;
IClassDefinition.IClassIterator classIterator = classDefinition.classIterator(project, true);
while (classIterator.hasNext()) {
c = (ClassDefinition) classIterator.next();
needsProtected |= c.getOwnNeedsProtected();
if (c != classDefinition) ancestorClassNames.add(c.getMName(project));
}
// Report a loop in the superclass chain, such as A extends B and B extends A.
// Note: A extends A was found previously by SemanticUtils.resolveBaseClass().
if (classIterator.foundLoop())
classScope.addProblem(new CircularTypeReferenceProblem(c, c.getQualifiedName()));
// In the case of class A extends A, ancestorClassNames will be empty at this point.
// Change it to be Object to prevent "Warning: Stack underflow" in the script init code below.
if (ancestorClassNames.isEmpty()) {
ClassDefinition objectDefinition =
(ClassDefinition) project.getBuiltinType(IASLanguageConstants.BuiltinType.OBJECT);
ancestorClassNames.add(objectDefinition.getMName(project));
}
// If this class or any of its ancestor classes needs the protected flag set, set it.
if (needsProtected) iinfo.flags |= ABCConstants.CLASS_FLAG_protected;
// Add the class initialization logic to the script init.
// For class B extends A, where class A extends Object, this looks like
// getscopeobject
// findpropstrict Object
// getproperty Object
// pushscope
// findpropstrict A
// getproperty A
// dup
// pushscope
// newclass
// popscope
// popscope
// initproperty B
InstructionList initInstructions = this.classScope.getInitInstructions();
initInstructions.addInstruction(OP_getscopeobject, 0);
// Push ancestor classes onto the scope stack.
for (int i = ancestorClassNames.size() - 1; i >= 0; i--) {
Name ancestorClassName = ancestorClassNames.get(i);
initInstructions.addInstruction(OP_getlex, ancestorClassName);
// The newclass instruction below also needs the superclass on the stack, so dup it
if (i == 0) initInstructions.addInstruction(OP_dup);
initInstructions.addInstruction(OP_pushscope);
}
initInstructions.addInstruction(OP_newclass, cinfo);
for (int i = 0; i < ancestorClassNames.size(); i++)
initInstructions.addInstruction(OP_popscope);
initInstructions.addInstruction(OP_initproperty, className);
implementedInterfaceSemanticChecks(class_definition);
processResourceBundles(class_definition, project, classScope.getProblems());
}