*

*  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.

*

*/

    /** The "*" type. */

    public static final Name anyType = null;

    /** Constant initializer not present. */

    public static final Object noInitializer = null;

    /**

     *  Manifest constant for "debug line number not known."

     */

    public static final int DEBUG_LINE_UNKNOWN = -1;

    private static final Name NAME_Array = new Name(IASLanguageConstants.Array);

    private static final Name NAME_arguments = new Name(IASLanguageConstants.arguments);

    private static final IMetaInfo[] EMPTY_META_INFO = new IMetaInfo[0];

    /**

     * Utility class to manage the allocation and merging of temps within

     * lexical scopes.

     */

    protected static class TempManager

    {

        /**

         *  Temporary registers allocated at this scope.

         */

        private final ArrayList<Binding> allocatedTemps;

        /**

         *  Allocated temporary registers that are free for re-use.

         */

        private final ArrayList<Binding> freeTemps;

        /**

         *  Index used to create unique names for temporary registers.

         *  @warn does not correspond to the temp's register number.

         */

        private int tempNum;

        /**

         * default constructor

         */

        protected TempManager()

        {

            allocatedTemps = new ArrayList<Binding>();

            freeTemps = new ArrayList<Binding>();

            tempNum = 0;

        }

        /**

         * Construct a TempManager which can be merged back into the supplied

         * tempManager.  This basically means that the temp numbering will never

         * overlap.

         *

         * @param tempManager the TempManager which this tempManager may be merged into

         */

        protected TempManager(TempManager tempManager)

        {

            this();

            tempNum = tempManager.tempNum;

        }

        protected Binding allocateTemp(boolean reuse_free)

        {

            Binding result;

            if ( this.freeTemps.isEmpty() || !reuse_free )

            {

                result = new Binding(null, new Name("Temp #" + tempNum++), null);

                result.setIsLocal(true);

                addAllocatedTemp(result);

            }

            else

            {

                result = this.freeTemps.remove(0);

            }

            return result;

        }

        protected void addAllocatedTemp(Binding temp)

        {

            this.allocatedTemps.add(temp);

        }

        protected void addAllocatedTemps(ImmutableList<Binding> temps)

        {

            for (Binding temp : temps)

                this.allocatedTemps.add(temp);

        }

        protected ImmutableList<Binding> getAllocatedTemps()

        {

            return ImmutableList.copyOf(this.allocatedTemps);

        }

        protected void clearAllocatedTemps()

        {

            this.allocatedTemps.clear();

        }

        protected void releaseTemp(Binding temp)

        {

            assert( !freeTemps.contains(temp) ): "Temp " + temp + " is already freed.";

            freeTemps.add(temp);

        }

        protected int initializeTempRegisters(int base)

        {

            for (Binding temp: allocatedTemps)

            {

                temp.setLocalRegister(base++);

            }

            return base;

        }

        protected void mergeTemps(TempManager tempManagerToMerge)

        {

            // first release all the temps in the TempManager being merged

            for (Binding temp : tempManagerToMerge.allocatedTemps)

            {

                if (!tempManagerToMerge.freeTemps.contains(temp))

                    tempManagerToMerge.releaseTemp(temp);

            }

            tempNum += tempManagerToMerge.tempNum;

            freeTemps.addAll(tempManagerToMerge.freeTemps);

            allocatedTemps.addAll(tempManagerToMerge.allocatedTemps);

        }

    }

    /**

     * Back reference to the global lexical scope

     */

    private final GlobalLexicalScope globalLexicalScope;

    /**

     *  Local variables.

     */

    private final Map <String,Binding>localBindings = new HashMap<String,Binding>();

    /**

     * Inlined functions local variables.

     */

    private List<Binding> inlinedBindings = null;

    /**

     *  LexicalScope (if present) that lexically encloses this one.

     */

    private final LexicalScope enclosingFrame;

    /**

     *  The MethodInfo of this scope's anonymous function,

     *  or null if this is not an anonymous function scope.

     */

    private MethodInfo methodInfo = null;

    /**

     *  Set if the function needs "this" on the scope stack.

     */

    private boolean needsThis = true;

    /**

     *  Parameter types of this scope's explicit parameters,

     *  not including any "..." parameter.

     */

    private Vector<Name> paramTypes = null;

    /**

     *  Set if the function has a "..." parameter.

     */

    private boolean hasRestParam = false;

    /**

     *  All implicit or explicit parameters, including a "..." parameter,

     *  defined by this scope's method on activation.

     */

    private final ArrayList<Name> allParams = new ArrayList<Name>();

    /**

     *  This scope's ControlFlowContextManager.

     *  The LexicalScope manages the ControlFlowContextManager

     *  because the CFCM depends on the LexicalScope to manage

     *  its temporaries.

     */

    private ControlFlowContextManager flowMgr = null;

    /**

     * The Binding that represents the register that the activation object is stored in.

     * This is used to restore the activation object when necessary - at the beginning

     * of a catch block for example. The value is null if the activation object is not

     * stored in a local.

     */

    private Binding activationStorage = null;

    /**

     *  Hasnext2Wapper objects (hasnext2 mangement objects)

     *  in use by this scope's code.  These are kept here so

     *  that the hasnext2 instruction can be informed of its

     *  allocated temps at function wrapup time.

     */

    private final ArrayList<Hasnext2Wrapper> hasnexts = new ArrayList<Hasnext2Wrapper>();

    /**

     * The syntax tree node for which this lexical scope was created, which is

     * also the node that scopes the visibility of labels for goto statements.

     * This can be null.

     */

    private IASNode initialControlFlowRegionNode;

    /**

     * Next slot id to allocate for traits.  Start at 1, as

     * 0 denotes VM allocated id.

     */

    private int slotId = 1;

    /**

     *  Initialization instructions for hoisted definitions

     *  (such as functions) that appear in the body of this

     *  scope but should occur at the routine prologue.

     *  Contrast initInsns, which is set only on scopes

     *  that collect results from many routines or code

     *  snippets (e.g., class scopes, the global scope).

     */

    private InstructionList hoistedInitInstructions = null;

    /**

     *  Local scope of the function (if any) under compilation.

     */

    private IASScope localScope = null;

    /**

     *  Names explicitly declared at this scope.

     */

    private final Set<Name>declaredVariables = new HashSet<Name>();

    /**

     *  Debug info: current file name.

     */

    private String currentDebugFile = null;

    /**

     *  Debug info: current line number.

     */

    private int currentDebugLine = -1;

    /**

     *  The nesting state of a function.

     */

    public enum NestingState { NotNested, Nested };

    /** Nesting state of this LexicalScope. */

    private NestingState nestingState = NestingState.NotNested;

    /**

     * {@link List} of {@link IVisitor}'s whose

     * {@link IVisitor#visitEnd()} method calls have been deferred

     * until we are known to be on the main code generation thread.

     */

    private final List<IVisitor>deferredVisitEnds = new LinkedList<IVisitor>();

    /** Enum to keep track of what references/decls of 'arguments' we have seen so far. */

    private enum ArgumentsState

    {

        INITIAL,    // seen neither a ref or a decl

        REFERENCED, // seen a ref, but not decl

        DECLARED,   // seen a decl

    }

    /**

     * The current state of 'arguments' referenced and declared

     */

    private ArgumentsState argumentsState = ArgumentsState.INITIAL;

    /**

     * Variables with visibility to nested scopes

     * are defined here.

     */

    ITraitsVisitor traitsVisitor = null;

    /**

     *  If this LexicalScope is the outer scope of a method

     *  compilation, this is its method body visitor.

     *  @see #getMethodBodyVisitor()

     */

    IMethodBodyVisitor methodBodyVisitor = null;

    /**

     *  If this LexicalScope is the outer scope of a method

     *  compilation, this is its method visitor.

     */

    IMethodVisitor methodVisitor = null;

    /**

     *  The semantic checker for this compilation.

     */

    protected MethodBodySemanticChecker methodBodySemanticChecker = null;

    /**

     * The temporary register manager for this lexical scope

     */

    private final TempManager tempManager;

    /**

     * constructor which should only ever be called

     * by {@link GlobalLexicalScope}

     */

    protected LexicalScope()

    {

        assert (this instanceof GlobalLexicalScope) : "LexicalScope() should only ever be called by GlobalLexicalScope()";

        this.globalLexicalScope = (GlobalLexicalScope)this;

        // GlobalLexicalScope should never have an enclosingFrame

        this.enclosingFrame = null;

        this.tempManager = new TempManager();

    }

    /**

     * constructor which is called whenever pushing a new

     * lexical scope

     *

     * @param enclosingFrame the parent frame

     */

    protected LexicalScope(LexicalScope enclosingFrame)

    {

        this(enclosingFrame, false);

    }

    /**

     * constructor which is called whenever pushing a new

     * lexical scope, and the temps are potentially going

     * to be shared with enclosing scope.

     *

     * @param enclosingFrame the parent frame

     */

    protected LexicalScope(LexicalScope enclosingFrame, boolean mergableTempManager)

    {

        assert (!(this instanceof GlobalLexicalScope)) : "LexicalScope(LexicalScope) should never be called by GlobalLexicalScope()";

        this.enclosingFrame = enclosingFrame;

        this.globalLexicalScope = enclosingFrame.globalLexicalScope;

        this.nestingState = enclosingFrame.nestingState;

        if (mergableTempManager)

            this.tempManager = new TempManager(enclosingFrame.tempManager);

        else

            this.tempManager = new TempManager();           

    }

    /*

     * ** Variable Management -- Creation **

     */

   

    /**

     * Create a variable with potential visibility

     * to nested scopes.

     *

     * @param var The variable binding

     */

    public void makeVariable(Binding var)

    {

        makeVariable(var, anyType, EMPTY_META_INFO);

    }

    /**

     * Create a variable with potential visibility

     * to nested scopes.

     *

     * @param var The variable binding

     * @param var_type The Name of the type of the variable

     * @param meta_tags The metadata on the variable

     */

    public void makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags)

    {

        makeVariable(var, var_type, meta_tags, noInitializer);

    }

    /**

     * Create a variable with potential visibility

     * to nested scopes.

     *

     * @param var The variable binding

     * @param var_type The Name of the type of the variable

     * @param meta_tags The metadata on the variable

     * @param initializer An initializer. null if no initializer. only consts can have an initializer

     */

    public void makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags, Object initializer)

    {

        makeVariable(var, var_type, meta_tags, initializer, VariableMutability.Default);

    }

    /**

     *  Mutability settings for a variable declaration.

     */

    public enum VariableMutability { Default, Variable, Constant };

    /**

     * Create a variable with potential visibility

     * to nested scopes.

     *

     * @param var The variable binding

     * @param var_type The Name of the type of the variable

     * @param meta_tags The metadata on the variable

     * @param initializer An initializer. null if no initializer. only consts can have an initializer

     * @param mutability - the caller's desired mutability.

     */

    public void makeVariable(Binding var, Name var_type, IMetaInfo[] meta_tags, Object initializer, VariableMutability mutability)

    {

        assert (initializer == null || SemanticUtils.isConstDefinition(var.getDefinition())) : "only consts can have an initializer";

        Name var_name = var.getName();

        if ( var_name == null || this.declaredVariables.contains(var_name) )

        {

            return;

        }

        declareVariableName(var_name);

        IDefinition var_def = var.getDefinition();

        if ( this.localsInRegisters() )

        {

            //  The Binding will already be in localBindings if it was referenced

            //  before it was set; if not, add it.

            if ( !this.localBindings.containsKey(var_name.getBaseName()) )

            {

                if ( var.getNode() instanceof BaseVariableNode )

                {

                    IExpressionNode name_node = ((BaseVariableNode)var.getNode()).getNameExpressionNode();

                    Binding var_binding = getBinding(name_node, var_name, var_def);

                    this.localBindings.put(var_name.getBaseName(), var_binding);

                    var_binding.setIsLocal(true);

                }

                else

                {

                    //  Error case, synthesize a Binding.

                    Binding error_binding = new Binding(var.getNode(), new Name("error in binding"), null);

                    this.localBindings.put(var_name.getBaseName(), error_binding);

                }

            }

        }

        else

        {

           

            int trait_kind;

            if ( SemanticUtils.isConstDefinition(var_def) || mutability == VariableMutability.Constant )

                trait_kind = ABCConstants.TRAIT_Const;

            else

                trait_kind = ABCConstants.TRAIT_Var;

            assert(this.traitsVisitor != null): "No traits";

            ITraitVisitor tv = this.traitsVisitor.visitSlotTrait(

                    trait_kind,

                    ensureQName(var_name),

                    getSlotId(var),

                    var_type,

                    initializer

            );

            tv.visitStart();

            processMetadata(tv, meta_tags);

            this.deferredVisitEnds.add(tv);

        }

    }

    private int getSlotId(Binding binding)

    {

        // only need to allocate slot ids when there's an activation

        // in the room, as we need to be able to reference the id when codegening setslot

        // and debug ops.  otherwise just let the VM handle the allocation.

        if (!needsActivation())

            return ITraitsVisitor.RUNTIME_SLOT;

        binding.setSlotId(slotId++);

        return binding.getSlotId();

    }

    /**

     * Helper method to determine if a variable binding has already been referenced.  When called before

     * makeVariable, it can be used to determine if the var was referenced before it was initialized, which means

     * it will need hoisted init instructions to make sure it has the right initial value.

     * @param var_name   The name for the  variable

     *

     * @return              true if the binding for var_name is already in the localBindings table

     */

    public boolean needsHoistedInitInsns (Name var_name, boolean has_initializer)

    {

        if ( this.localsInRegisters() )

        {

            // If it's a re-decl of a parameter, then don't add hoisted init instructions

            if( allParams.contains(var_name) )

                return false;

            // If there is no explicit initializer, then we need to init the local

            // could do better here - if it's never ref'ed before being assigned to

            // might be able to omit the initializer too

            if( !has_initializer )

                return true;

            //  The Binding will already be in localBindings if it was referenced

            //  before it was set

            Binding b = this.localBindings.get(var_name.getBaseName());

            return b != null ;

        }

        return false;

    }

    /**

     *  Add a variable name to the set of known names.

     *  @param n - the Name to add.

     */

    public void declareVariableName(Name n)

    {

        checkForArgumentsDecl(n);

        this.declaredVariables.add(n);

    }

    /**

     * Create a bindable property. This will create a getter/setter that will do

     * the bindable magic, and a backing property that will store the actual

     * value.

     * <p>

     * This method must only be called on the thread that started code

     * generation of the syntax tree that contains the bindable variable. This

     * constraint is met today, because we do not generate code for classes in

     * parallel and bindable variables are always be class members.

     *

     * @param metaTags The IMetaTagsNode representing the metadata nodes for

     * this definition. If it is null, this method will ask the varDef for the

     * metadata - some callers of this method will not have an MetaTagsNode in

     * the AST, and want the metadata from the definition

     */

    public void makeBindableVariable(Binding var, Name var_type, IMetaInfo[] metaTags)

    {

        Name var_name = var.getName();

        if ( var_name == null || this.declaredVariables.contains(var_name) )

        {

            return;

        }

        declareVariableName(var_name);

        Name backingPropertyName = BindableHelper.getBackingPropertyName(var_name);

        assert(this.traitsVisitor != null): "No traits";

        this.traitsVisitor.visitSlotTrait(

            ABCConstants.TRAIT_Var,

            ensureQName(backingPropertyName),

            getSlotId(var),

            var_type,

            noInitializer

        );

        IDefinition bindableVarDef = var.getDefinition();

       

        generateBindableGetter(bindableVarDef, var_name, backingPropertyName, var_type, metaTags);

        generateBindableSetter(bindableVarDef, var_name, backingPropertyName, var_type, metaTags);

    }

   

    public void generateBindableGetter(IDefinition bindableVarDef, Name var_name, Name backingPropertyName, Name var_type, IMetaInfo[] metaTags)

    {

        ITraitVisitor getterTv = BindableHelper.generateBindableGetter(this, var_name, backingPropertyName, var_type);

        IMetaTag gotoDefinitionMetaTag = MetaTag.createGotoDefinitionHelp(bindableVarDef,

                bindableVarDef.getContainingFilePath(),

                Integer.toString(bindableVarDef.getNameStart()), false);

        metaTags = MetaTag.addMetaTag(metaTags, gotoDefinitionMetaTag);

       

        // If we have an IMetaTagsNode use that, otherwise get the metadata from the definition

            processMetadata(getterTv, metaTags);

            if (bindableVarDef.isOverride())

                getterTv.visitAttribute(Trait.TRAIT_OVERRIDE, Boolean.TRUE);

        // We don't codegen classes in parallel right now,

        // so we know that we are on the main code generation thread

        // because bindable variables are always members of a class.

        // Since we know are on the main code generation thread we can immediately

        // call visitEnd here and the vistEnd calls in generateBindableSetter

        // are ok too.

        getterTv.visitEnd();

    }

   

    public void generateBindableSetter(IDefinition bindableVarDef, Name var_name, Name backingPropertyName, Name var_type, IMetaInfo[] metaTags)

    {

        ITraitVisitor setterTv = BindableHelper.generateBindableSetter(this, var_name, backingPropertyName, var_type, bindableVarDef);

       

        IMetaTag gotoDefinitionMetaTag = MetaTag.createGotoDefinitionHelp(bindableVarDef,

                bindableVarDef.getContainingFilePath(),

                Integer.toString(bindableVarDef.getNameStart()), false);

        metaTags = MetaTag.addMetaTag(metaTags, gotoDefinitionMetaTag);

       

        processMetadata(setterTv, metaTags);

       

        if (bindableVarDef.isOverride())

            setterTv.visitAttribute(Trait.TRAIT_OVERRIDE, Boolean.TRUE);

        setterTv.visitEnd();

    }

    /**

     *  Workaround namerezo's habit of returning a multiname

     *  for a local definition if the definition was referenced

     *  before it was declared.

     *  @param n - the name per name resolution.

     *  @return the input name if it was a QName, or a QName

     *    with the same base name and a more or less appropriate

     *    qualifier if it was not a QName.

     */

    private Name ensureQName(Name n)

    {

        Name result;

        if ( n != null )

        {

            if ( n.getKind() == ABCConstants.CONSTANT_Qname )

            {

                result = n;

            }

            else

            {

                result = new Name(ABCConstants.CONSTANT_Qname, new Nsset(new Namespace(ABCConstants.CONSTANT_PackageNs)), n.getBaseName());

            }

        }

        else

        {

            result = null;

        }

        return result;

    }

    /**

     *  Declare and define a namespace.

     *  @param ns_binding - the namespace declaration's binding.

     *  @param ns_init - the namespace definition's initial AET Namespace.  May not be null.

     */

    public void makeNamespace(Binding ns_binding, Namespace ns_init)

    {

        Name ns_name = ns_binding.getName();

        //  TODO: Semantic analysis will issue a diagnostic.

        //  Repair locally by ignoring the second declaration.

        if ( this.declaredVariables.contains(ns_name))

            return;

        else

            declareVariableName(ns_name);

        assert ( ns_init != null );

        assert(this.traitsVisitor != null): "No traits";

        if ( this.localsInRegisters() )

        {

            this.localBindings.put(ns_name.getBaseName(), ns_binding);

            ns_binding.setIsLocal(true);

        }

        else

        {

            this.traitsVisitor.visitSlotTrait(ABCConstants.TRAIT_Const, ns_name, getSlotId(ns_binding), anyType, ns_init);

        }

    }

    /*

     * ** Variable Management -- Local Variables **

     */

   

   

    /**

     *  Declare an explicit parameter.

     *  @param def - the parameter's definition.

     *  @param param_type - the name of the parameter's type.

     */

    public void makeParameter(IDefinition def, Name param_type)

    {

        Name param_name = ((DefinitionBase)def).getMName(getProject());

        if (((IParameterDefinition)def).isRest())

            hasRestParam = true;

        else

            getParamTypes().add(param_type);

       

        allParams.add(param_name);

        Binding var = getBinding(def);

        makeVariable(var, param_type, EMPTY_META_INFO);

    }

    /**

     *  Declare an implicit parameter.

     *  The only implicit parameter in AS3 is <code>arguments</code>.

     *  @param param_name - the parameter's name.

     *  @param param_type - the name of the parameter's type.

     */

    private void makeImplicitParameter(Name param_name, Name param_type)

    {

        allParams.add(param_name);

        //  Add this parameter's name to the set of

        //  locally defined variables.

        Binding var = getBinding(null, param_name, null);

        makeVariable(var, param_type, EMPTY_META_INFO);

    }

    /**

     *  Add a default value to the currently compiling method.

     *  @see #makeParameter which is called first.

     *  @note Why is this not folded into makeParameter()?  Because

     *    null is a valid initial value.

     */

    public void addDefaultValue(PooledValue value)

    {

        if( value != null )

            this.methodInfo.addDefaultValue(value);

    }

    /**

     * @return true if "this" needed.

     */

    public boolean needsThis()

    {

        return this.needsThis;

    }

    /**

     *  @return the types of this scope's function parameters.

     */

    public Vector<Name> getParamTypes()

    {

        if ( this.paramTypes == null)

            this.paramTypes = new Vector<Name>();

        return this.paramTypes;

    }

    /**

     *  @return this scope's MethodInfo, or null if none present.

     */

    public MethodInfo getMethodInfo()

    {

        return this.methodInfo;

    }

    /**

     *  sets this scope's MethodInfo,

     */

    public void setMethodInfo(MethodInfo methodInfo)

    {

        assert (this.methodInfo == null) : "trying to set an already set methodInfo";

        this.methodInfo = methodInfo;

        //  Setting a MethodInfo means we're generating a method body,

        //  so we need a fresh MethodBodySemanticChecker.

        this.methodBodySemanticChecker = new MethodBodySemanticChecker(this);

    }

    /**

     *  Reset this scope's MethodInfo to null; called from

     *  a ClassDirectiveProcessor's static initialization

     *  error recovery logic.

     */

    public void resetMethodInfo()

    {

        this.methodInfo = null;

        this.methodBodySemanticChecker = null;

    }

    /**

     *  Allocate a temporary register.  The temp is

     *  assumed to hold the "*" type.

     *  @return the temp register's Binding.

     *    A temp's Binding is used to hold

     *    the get/set/kill, etc., instructions

     *    that relate to it.

     */

    public Binding allocateTemp()

    {

        return allocateTemp(true);

    }

    /**

     * Allocate a temporary register.

     * @param reuse_free - re-use a free temp if set.

     * @return the temp's local number.

     */

    public Binding allocateTemp(boolean reuse_free)

    {

        return tempManager.allocateTemp(reuse_free);

    }

    /**

     * Release a temporary register.

     * @param temp - the temp's Binding.

     * @see #allocateTemp()

     */

    public void releaseTemp(Binding temp)

    {

        tempManager.releaseTemp(temp);

    }

    /**

     * Merge the temps from the specified lexical scope into this lexical scope.

     *

     * @param scopeToMerge the scope containing the temps to merge

     */

    protected void mergeTemps(LexicalScope scopeToMerge)

    {

        tempManager.mergeTemps(scopeToMerge.tempManager);

    }

    /**

     * Add a collection of bindings to the collection of inlined bindings

     * in this lexical scope.

     *

     * @param bindings the bindings to add

     */

    protected void addInlinedBindings(Collection<Binding> bindings)

    {

        if (inlinedBindings == null)

            inlinedBindings = new ArrayList<Binding>();

        inlinedBindings.addAll(bindings);

    }

    /**

     * Add a collection of hasnext wrappers to the collection of

     * hasnexts in this lexical scope.

     *

     * @param nexts the hasnexts to add

     */

    protected void addHasNexts(Collection<Hasnext2Wrapper> nexts)

    {

        hasnexts.addAll(nexts);

    }

    /**

     * @return collection of Hasnext2Wrappers

     */

    protected Collection<Hasnext2Wrapper> getHasNexts()

    {

        return hasnexts;

    }

    /**

     * @return All the local bindings in the lexical scope.

     */

    protected Collection<Binding> getLocalBindings()

    {

        return localBindings.values();

    }

    /**

     *  Allocate a hasnext2 management object.

     *  @return the new hasnext2 management object.

     */

    Hasnext2Wrapper hasnext2()

    {

        Hasnext2Wrapper hasnext = new Hasnext2Wrapper();

        this.hasnexts.add(hasnext);

        hasnext.stem_temp  = allocateTemp(false);

        hasnext.index_temp = allocateTemp(false);

        return hasnext;

    }

     *  Hasnext2Wapper is a struct-like class

     *  that holds the temps and instruction

     *  that comprise a hasnext2 operation.

     */

    class Hasnext2Wrapper

    {

        Binding stem_temp, index_temp;

        Instruction instruction = InstructionFactory.getHasnext2Instruction();

        /**

         *  Release the temps from a hasnext2.

         */

        public void release()

        {

            releaseTemp(index_temp);

            releaseTemp(stem_temp);

        }

    }

    /**

     * @return the LexicalScope's corresponding ASScope.

     */

    public IASScope getLocalASScope()

    {

        return this.localScope;

    }

    /**

     *  Set this LexicalScope's corresponding ASScope.

     */

    public void setLocalASScope(IASScope scope)

    {

        assert this.localScope == null || this.localScope == scope : "Local scope already set.";

        this.localScope = scope;

    }

    /**

     *  @return true if the candidate definition is local to this LexicalScope's corresponding ASScope.

     *  @param candidate - the IDefinition under examination.

     */

    public boolean isLocalDefinition(IDefinition candidate)

    {

        return candidate != null && candidate.getContainingScope() != null && candidate.getContainingScope() == this.localScope;

    }

    /*

     * ** Name Management **

     */

    /**

     * Resolve a name, and return a Binding for it.

     * The Binding will include information such as

     * the multiname (or qname), and local register info

     * @param id  The IdentifierNode you need a Binding for

     * @return  A Binding

     */

    public Binding resolveName(IdentifierNode id)

    {

        ICompilerProject project = getProject();

        if(id instanceof ILanguageIdentifierNode)

        {

            ILanguageIdentifierNode lang_id = (ILanguageIdentifierNode)id;

            LanguageIdentifierKind kind = lang_id.getKind();

            if ( kind == LanguageIdentifierKind.THIS )

            {

                return getThisBinding(id);

            }

            else if ( kind == LanguageIdentifierKind.ANY_TYPE )

            {

                return new Binding(id, id.getMName(project), id.resolve(project));

            }

            else if ( kind == LanguageIdentifierKind.VOID )

            {

                return new Binding(id, id.getMName(project), id.resolve(project));

            }

            else

            {

                assert false: "Unhandled LanguageIdentifierKind " + kind;

            }

        }

        IDefinition def = id.resolve(project);

        Name name;

        if ( id.getName().length() == 0 )

            name = new Name(getGlobalScope().getSyntheticName("anonymous"));

        else

            name = id.getMName(project);

        if( SemanticUtils.isRefToClassBeingInited(id, def) && !insideInlineFunction())

        {

            // Return a slightly modified binding

            // this binding will have the name and node that created the binding,

            // but its local will be set to 0, so that getlocal0 will be used instead of a name lookup

            // this is because we are in code that may be run as part of the class cinit method, and the

            // class slot won't have been initialized yet, so a named lookup will fail.

            // class C

            // {

            //    static var a = C; //C must be codegen'ed as getlocal0 instead of findprop, getprop

            // }

            Binding b = getBinding(id, name, def);

            b.setIsLocal(true);

            b.setLocalRegister(0);

            return b;

        }

        else if ( name != null )

        {

            return getBinding(id, name, def);

        }

  else

  {

      //  Error case, return trivial name

      return new Binding(id, new Name(id.getName()), def);

  }

    }

    /**

     *  Get or create the Binding for an IDefinition.

     *  @param def - the IDefinition.

     *  @return said Binding.

     */

    public Binding getBinding(IDefinition def)

    {

        return getBinding(null, getNameFromDefinition(def), def);

    }

    /**

     *  Get or create the Binding for a Name and its associated IDefinition.

     *  @param name -  the name under consideration.

     *  @param def - the name's IDefinition.

     *  @return said Binding.

     */

    public Binding getBinding(IASNode node, Name name, IDefinition def)

    {

        if (name != null && isLocalDefinition(def) && this.localBindings.containsKey(name.getBaseName()) )

        {

            Binding b = localBindings.get(name.getBaseName());

            // return a new Binding to make sure it has the right Node.

            return new Binding(node, b);

        }

        else

        {

            Binding result = new Binding(node, name, def);

            if ( isLocalDefinition(def) )

            {

                this.localBindings.put(name.getBaseName(), result);

                if ( this.localsInRegisters() )

                    result.setIsLocal(true);

            }

            checkForArgumentsReference(result);

            return result;

        }

    }

    /**

     * Determine if this method needs to set the NEEDS_Arguments flag.  It only needs

     * to if arguments is referenced somewhere in the method, and arguments is not declared in the method.

     * @return

     */

    private boolean needsImplicitArguments ()

    {

        // We only need the arguments flag if arguments was referenced, but never declared.

        return argumentsState == ArgumentsState.REFERENCED;

    }

    /**

     * Check if the node and name passed in are declaration of a property named 'arguments'.

     * Necessary so we can generate NEEDS_Arguments flag on the MethodInfo if needed.

     * @param name  The Name of the reference

     */

    private void checkForArgumentsDecl (Name name)

    {

        if( name != null && IASLanguageConstants.arguments.equals(name.getBaseName()) )

        {

            switch(argumentsState)

            {

                case INITIAL:

                case REFERENCED:

                    argumentsState = ArgumentsState.DECLARED;

                    break;

                case DECLARED:

                    break;

            }

        }

    }

    /**

     * Check if the binding is a potential reference to the arguments object

     * Necessary so we can generate NEEDS_Arguments flag on the MethodInfo if needed.

     * @param b  The node that produced the reference

     */

    private void checkForArgumentsReference (Binding b)

    {

        if( SemanticUtils.isArgumentsReference(b) )

        {

            switch(argumentsState)

            {

                case INITIAL:

                    argumentsState = ArgumentsState.REFERENCED;

                    break;

                case REFERENCED:

                case DECLARED:

                    break;

            }

        }

    }

    /**

     * Get the local binding for the given name, if one exists

     * @param name  the name of the local

     * @return      the Binding for the local property, or null if there isn't one.

     */

    Binding getLocalBinding(Name name)

    {

        if ( name != null )

            return localBindings.get(name.getBaseName());

        else

            return null;

    }

    /**

     *  Extract a definition's name.

     */

    private Name getNameFromDefinition(IDefinition idef)

    {

        DefinitionBase def = (DefinitionBase)idef;

        return def.getMName(getProject());

    }

    /**

     *  Fetch the Binding that represents "this."

     *  @return said Binding.

     */

    protected Binding getThisBinding(IdentifierNode id)

    {

        Binding thisBinding = new Binding(id, null, null);

        thisBinding.setIsLocal(true);

        thisBinding.setLocalRegister(0);

        return thisBinding;

    }

    /**

     * Get the property for the specified binding.  Use this method rather

     * than using findprop directly, because inlining needs to do some magic

     *

     * @param binding Binding of the property to find

     * @param useStrict Use OP_findpropstrict

     * @return InstructionList

     */

    public InstructionList findProperty(Binding binding, boolean useStrict)

    {

        return findProperty(binding.getName(), binding.getDefinition(), useStrict);

    }

    /**

     * Get the property for the specified name.  Use this method rather

     * than using findprop directly, because inlining needs to do some magic

     *

     * @param name Name of the property to find

     * @param def Definition of the property to find

     * @param useStrict Use OP_findpropstrict

     * @return InstructionList

     */

    public InstructionList findProperty(Name name, IDefinition def, boolean useStrict)

    {

        InstructionList result = new InstructionList(1);

        if (useStrict)

            result.addInstruction(OP_findpropstrict, name);

        else

            result.addInstruction(OP_findproperty, name);

        return result;

    }

    /**

     * Get the property value for the specified binding. Use this method rather

     * than using getlex directly, because inlining needs to do some magic

     *

     * @param binding Binding of the property to find

     * @return InstructionList

     */

    public InstructionList getPropertyValue(Binding binding)

    {

        return getPropertyValue(binding.getName(), binding.getDefinition());

    }

    /**

     * Get the property value for the specified name. Use this method rather

     * than using getlex directly, because inlining needs to do some magic

     *

     * @param name Name of the property to find

     * @param def Definition of the property to find

     * @return InstructionList

     */

    public InstructionList getPropertyValue(Name name, IDefinition def)

    {

        InstructionList result = new InstructionList(1);

        result.addInstruction(OP_getlex, name);

        return result;

    }

    /**

     *  @return this scope's enclosing scope.

     */

    public LexicalScope getEnclosingFrame()

    {

        return enclosingFrame;

    }

    /**

     *  Finalize a method's declarations.

     *  @param has_body - true if the method

     *    has a non-empty body.

     *  @return an InstructionList containing

     *    the method's prologue instructions.

     */

    InstructionList finishMethodDeclaration(final boolean hasBody, String source_path)

    {

        InstructionList result = new InstructionList();

        // TODO: The scope stack can be optimized out if

        // no instruction (e.g., findprop) requires one.

        if ( this.needsThis )

            // && this.needsScopeStack() )

        {

            result.addInstruction(ABCConstants.OP_getlocal0);

            result.addInstruction(ABCConstants.OP_pushscope);

        }

        // Add a debugfile to start the method.

        if( source_path != null )

        {

            String encoded_filename = getGlobalScope().getEncodedDebugFile(source_path);

            result.addInstruction(ABCConstants.OP_debugfile, encoded_filename);

        }

        // TODO: Set this more intelligently;

        // it's only necessary if arguments is read but not written.

        if (needsImplicitArguments())

        {

            this.setNeedsArguments();

        }

        if ( this.needsArguments() )

        {

            makeImplicitParameter(NAME_arguments, NAME_Array);

        }

        if ( !isGlobalScope() )

        {

            // temp_register_count is the total number of temp registers

            // which need to be initialized.

            int temp_register_count = 0;

            if ( this.needsActivation() )

            {

                //  Create a new activation object, store it in a local (so it can be restored

                //  if needed later, like in a catch block), and push the activation object

                //  onto the scope stack.

                result.addInstruction(ABCConstants.OP_newactivation);

                if( this.activationStorage != null )

                {

                    result.addInstruction(ABCConstants.OP_dup);

                    result.addInstruction(this.activationStorage.setlocal());

                }

                result.addInstruction(ABCConstants.OP_pushscope);

                //  TODO: More fine-grained determination

                //  of which parameters need to live in the activation record.

                for ( int param_num = 0; param_num < this.allParams.size(); param_num++ )

                {

                    Name param_name = this.allParams.get(param_num);

                    result.addInstruction(ABCConstants.OP_findpropstrict, param_name);

                    //  Parameter numbering in the AVM is 1-based

                    //  since local 0 holds "this."

                    result.addInstruction(ABCConstants.OP_getlocal, param_num + 1);

                    result.addInstruction(ABCConstants.OP_setproperty, param_name);

                }

                temp_register_count = this.allParams.size() + 1;

            }

            else

            {

                // Find the bindings for the parameters

                // and give them their corresponding local number.

                // There is a complication, however. The same parameter name may occur more than

                // Once in the parameter list. In this case, ECMA says the last one wins.

                // So in the loop below will go from last parameter to first, and skip any

                // that we have already seen