/*
 *
 *  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.royale.compiler.internal.codegen.js.utils;

import java.util.*;

import org.apache.royale.compiler.constants.IASKeywordConstants;
import org.apache.royale.compiler.constants.IASLanguageConstants;
import org.apache.royale.compiler.constants.IASLanguageConstants.BuiltinType;
import org.apache.royale.compiler.constants.INamespaceConstants;
import org.apache.royale.compiler.definitions.IClassDefinition;
import org.apache.royale.compiler.definitions.IDefinition;
import org.apache.royale.compiler.definitions.IFunctionDefinition;
import org.apache.royale.compiler.definitions.IFunctionDefinition.FunctionClassification;
import org.apache.royale.compiler.definitions.ITypeDefinition;
import org.apache.royale.compiler.definitions.IVariableDefinition;
import org.apache.royale.compiler.internal.codegen.js.JSEmitterTokens;
import org.apache.royale.compiler.internal.codegen.js.JSSessionModel;
import org.apache.royale.compiler.internal.codegen.js.royale.JSRoyaleEmitterTokens;
import org.apache.royale.compiler.internal.definitions.AccessorDefinition;
import org.apache.royale.compiler.internal.definitions.ClassDefinition;
import org.apache.royale.compiler.internal.definitions.FunctionDefinition;
import org.apache.royale.compiler.internal.definitions.InterfaceDefinition;
import org.apache.royale.compiler.internal.definitions.NamespaceDefinition.INamepaceDeclarationDirective;
import org.apache.royale.compiler.internal.definitions.ParameterDefinition;
import org.apache.royale.compiler.internal.definitions.VariableDefinition;
import org.apache.royale.compiler.internal.semantics.SemanticUtils;
import org.apache.royale.compiler.internal.tree.as.*;
import org.apache.royale.compiler.internal.tree.as.ConfigConditionBlockNode;
import org.apache.royale.compiler.internal.tree.as.ContainerNode;
import org.apache.royale.compiler.internal.tree.as.NodeBase;
import org.apache.royale.compiler.internal.tree.as.ParameterNode;
import org.apache.royale.compiler.projects.ICompilerProject;
import org.apache.royale.compiler.tree.ASTNodeID;
import org.apache.royale.compiler.tree.as.*;
import org.apache.royale.compiler.utils.DefinitionUtils;
import org.apache.royale.compiler.utils.NativeUtils;

/**
 * Various static methods used in shared emitter logic.
 */
public class EmitterUtils
{

    private static final Set<String> alwaysExcludeImports;

    static {
        //initialize the 'always' excluded imports in alwaysExcludeImports
        Set<String> temp = new HashSet<String>();
        //if any others are needed to always be avoided, add them here:
        temp.add(JSRoyaleEmitterTokens.JS_UNSAFE_INLINE_FUNCTION_NAME.getToken());

        alwaysExcludeImports = Collections.unmodifiableSet(temp);
    }

    public static ITypeNode findTypeNode(IPackageNode node)
    {
        IScopedNode scope = node.getScopedNode();
        for (int i = 0; i < scope.getChildCount(); i++)
        {
            IASNode child = scope.getChild(i);
            if (child instanceof ITypeNode)
                return (ITypeNode) child;
            else if (child.getNodeID() == ASTNodeID.ConfigBlockID)
            {
            	ConfigConditionBlockNode configNode = (ConfigConditionBlockNode)child;
            	if (configNode.getEnabled() && configNode.getChildCount() > 0)
            	{
            		for (int j = 0; j < configNode.getChildCount(); j++)
            		{
                		child = configNode.getChild(j);
                        if (child instanceof ITypeNode)
                            return (ITypeNode) child;            			
            		}
            	}
            }
        }
        return null;
    }

    public static ITypeDefinition findType(Collection<IDefinition> definitions)
    {
        for (IDefinition definition : definitions)
        {
            if (definition instanceof ITypeDefinition)
                return (ITypeDefinition) definition;
        }
        return null;
    }

    public static INamepaceDeclarationDirective findNamespace(Collection<IDefinition> definitions)
    {
        for (IDefinition definition : definitions)
        {
            if (definition instanceof INamepaceDeclarationDirective)
                return (INamepaceDeclarationDirective) definition;
        }
        return null;
    }
    
    public static INamespaceNode findNamespaceNode(IPackageNode node)
    {
        IScopedNode scope = node.getScopedNode();
        for (int i = 0; i < scope.getChildCount(); i++)
        {
            IASNode child = scope.getChild(i);
            if (child instanceof INamespaceNode)
                return (INamespaceNode) child;
        }
        return null;
    }

    public static IFunctionDefinition findFunction(Collection<IDefinition> definitions)
    {
        for (IDefinition definition : definitions)
        {
            if (definition instanceof IFunctionDefinition)
                return (IFunctionDefinition) definition;
        }
        return null;
    }

    public static IFunctionNode findFunctionNode(IPackageNode node)
    {
        IScopedNode scope = node.getScopedNode();
        for (int i = 0; i < scope.getChildCount(); i++)
        {
            IASNode child = scope.getChild(i);
            if (child instanceof IFunctionNode)
                return (IFunctionNode) child;
        }
        return null;
    }

    public static IVariableNode findVariableNode(IPackageNode node)
    {
        IScopedNode scope = node.getScopedNode();
        for (int i = 0; i < scope.getChildCount(); i++)
        {
            IASNode child = scope.getChild(i);
            if (child instanceof IVariableNode)
                return (IVariableNode) child;
        }
        return null;
    }

    public static IVariableDefinition findVariable(Collection<IDefinition> definitions)
    {
        for (IDefinition definition : definitions)
        {
            if (definition instanceof IVariableDefinition)
                return (IVariableDefinition) definition;
        }
        return null;
    }

    public static ITypeDefinition getTypeDefinition(IDefinitionNode node)
    {
        ITypeNode tnode = (ITypeNode) node.getAncestorOfType(ITypeNode.class);
        if (tnode != null)
        {
            return (ITypeDefinition) tnode.getDefinition();
        }
        return null;
    }

    public static boolean isSameClass(IDefinition pdef, IDefinition thisClass,
            ICompilerProject project)
    {
        if (pdef == thisClass)
            return true;

        IDefinition cdef = ((ClassDefinition) thisClass)
                .resolveBaseClass(project);
        while (cdef != null)
        {
            // needs to be a loop
            if (cdef == pdef)
                return true;
            cdef = ((ClassDefinition) cdef).resolveBaseClass(project);
        }
        return false;
    }

    public static boolean hasSuperClass(ICompilerProject project,
            IDefinitionNode node)
    {
        IClassDefinition superClassDefinition = getSuperClassDefinition(node,
                project);
        // XXX (mschmalle) this is nulling for MXML super class, figure out why
        if (superClassDefinition == null)
            return false;
        String qname = superClassDefinition.getQualifiedName();
        return superClassDefinition != null
                && !qname.equals(IASLanguageConstants.Object);
    }

    public static boolean hasSuperCall(IScopedNode node)
    {
        for (int i = node.getChildCount() - 1; i > -1; i--)
        {
            IASNode cnode = node.getChild(i);
            if (cnode.getNodeID() == ASTNodeID.FunctionCallID
                    && cnode.getChild(0).getNodeID() == ASTNodeID.SuperID)
                return true;
        }

        return false;
    }

    public static boolean hasBody(IFunctionNode node)
    {
        IScopedNode scope = node.getScopedNode();
        return scope.getChildCount() > 0;
    }

    public static IClassDefinition getSuperClassDefinition(
            IDefinitionNode node, ICompilerProject project)
    {
        IDefinition parent = node.getDefinition().getParent();
        if (parent instanceof IClassDefinition)
        {
            IClassDefinition parentClassDef = (IClassDefinition) parent;
            IClassDefinition superClass = parentClassDef.resolveBaseClass(project);
            return superClass;
        }
        return null;
    }

    public static List<String> resolveImports(ITypeDefinition type)
    {
        ArrayList<String> list = new ArrayList<String>();
        IScopedNode scopeNode = type.getContainedScope().getScopeNode();
        if (scopeNode != null)
        {
            scopeNode.getAllImports(list);
        }
        else
        {
            // MXML
            ClassDefinition cdefinition = (ClassDefinition) type;
            String[] implicitImports = cdefinition.getImplicitImports();
            for (String imp : implicitImports)
            {
                list.add(imp);
            }
        }
        //automatic 'always' exclusions from imports:
        removeExcludedImports(list);
        return list;
    }

    public static boolean shouldExcludeImport(String importString) {
        return alwaysExcludeImports.contains(importString);
    }

    public static void removeExcludedImports(List<String> list) {
        for (String listItem:list) {
            if (shouldExcludeImport(listItem)) {
                list.remove(listItem);
            }
        }
        // list.removeIf(EmitterUtils::shouldExcludeImport);
    }

    public static IClassDefinition getClassDefinition(IDefinitionNode node)
    {
        IClassNode tnode = (IClassNode) node
                .getAncestorOfType(IClassNode.class);
        return (tnode != null) ? tnode.getDefinition() : null;
    }

    public static IParameterNode getRest(IParameterNode[] nodes)
    {
        for (IParameterNode node : nodes)
        {
            if (node.isRest())
                return node;
        }

        return null;
    }

    public static Map<Integer, IParameterNode> getDefaults(
            IParameterNode[] nodes)
    {
        Map<Integer, IParameterNode> result = new HashMap<Integer, IParameterNode>();
        int i = 0;
        boolean hasDefaults = false;
        for (IParameterNode node : nodes)
        {
            if (node.hasDefaultValue())
            {
                hasDefaults = true;
                result.put(i, node);
            }
            else
            {
                result.put(i, null);
            }
            i++;
        }

        if (!hasDefaults)
            return null;

        return result;
    }

    public static boolean writeThis(ICompilerProject project,
            JSSessionModel model, IIdentifierNode node)
    {
        IClassNode classNode = (IClassNode) node
                .getAncestorOfType(IClassNode.class);

        IDefinition nodeDef = node.resolve(project);

        IASNode parentNode = node.getParent();
        ASTNodeID parentNodeId = parentNode.getNodeID();

        IASNode firstChild = parentNode.getChild(0);

        final IClassDefinition thisClass = model.getCurrentClass();

        boolean identifierIsMemberAccess = parentNodeId == ASTNodeID.MemberAccessExpressionID;

        if (nodeDef instanceof ParameterDefinition)
            return false;
        if (nodeDef instanceof InterfaceDefinition)
            return false;
        if (nodeDef instanceof ClassDefinition)
            return false;
        
        if (classNode == null) // script in MXML and AS interface definitions
        {
        	if (parentNodeId == ASTNodeID.FunctionCallID && model.inE4xFilter)
        	{
        		// instance methods must be qualified with 'this'?
        		// or maybe we need to test if identifier exists on XML/XMLList
        		return false;
        	}
            if (nodeDef instanceof VariableDefinition)
            {
                IDefinition pdef = ((VariableDefinition) nodeDef).getParent();

                if (thisClass == null || !isSameClass(pdef, thisClass, project))
                    return false;

                if (identifierIsMemberAccess)
                    return node == firstChild;

                return parentNodeId == ASTNodeID.ContainerID
                        || !(parentNode instanceof ParameterNode);
            }
            else if (nodeDef instanceof AccessorDefinition)
            {
                IDefinition pdef = ((AccessorDefinition) nodeDef).getParent();

                if (thisClass == null || !isSameClass(pdef, thisClass, project))
                    return false;

                if (identifierIsMemberAccess)
                    return node == firstChild;

                return true;
            }
            else if (parentNodeId == ASTNodeID.ContainerID
                    && nodeDef instanceof FunctionDefinition)
            {
                return ((FunctionDefinition) nodeDef)
                        .getFunctionClassification() == FunctionClassification.CLASS_MEMBER; // for 'goog.bind'
            }
            else
            {
                boolean isFileOrPackageMember = false;
                boolean isLocalFunction = false;
                if(nodeDef instanceof FunctionDefinition)
                {
                    FunctionClassification classification = ((FunctionDefinition) nodeDef).getFunctionClassification();
                    if(classification == FunctionClassification.FILE_MEMBER ||
                            classification == FunctionClassification.PACKAGE_MEMBER)
                    {
                        isFileOrPackageMember = true;
                    }
                    else if (!identifierIsMemberAccess && classification == FunctionClassification.CLASS_MEMBER &&
                            isClassMember(project, nodeDef, thisClass))
                    {
                        return true;
                    }
                    else if (classification == FunctionClassification.LOCAL)
                    {
                        isLocalFunction = true;
                    }
                }
                return parentNodeId == ASTNodeID.FunctionCallID
                        && !(nodeDef instanceof AccessorDefinition)
                        && !identifierIsMemberAccess
                        && !isFileOrPackageMember
                        && !isLocalFunction;
            }
        }
        else
        {
        	if (parentNodeId == ASTNodeID.FunctionCallID && model.inE4xFilter)
        	{
        		// instance methods must be qualified with 'this'?
        		// or maybe we need to test if identifier exists on XML/XMLList
        		return false;
        	}
            if (nodeDef != null
                    && isClassMember(project, nodeDef, classNode))
            {
                if (identifierIsMemberAccess)
                {
                    return node == firstChild;
                }
                else
                {
                    boolean identifierIsLocalFunction = nodeDef instanceof FunctionDefinition
                            && !(nodeDef instanceof AccessorDefinition)
                            && ((FunctionDefinition) nodeDef)
                                    .getFunctionClassification() == IFunctionDefinition.FunctionClassification.LOCAL;

                    return !identifierIsLocalFunction;
                }
            }
        }

        return false;
    }

    public static boolean isClassMember(ICompilerProject project,
            IDefinition nodeDef, IClassNode classNode)
    {
        IDefinition parentDef = nodeDef.getParent();
    	if (nodeDef.isInternal() && (!(parentDef instanceof ClassDefinition)))
    		return false;
    	
        IClassDefinition cdef = classNode.getDefinition();
        return parentDef == cdef || (parentDef instanceof ClassDefinition && cdef.isInstanceOf((ClassDefinition)parentDef, project));
    }
    
    public static boolean isClassMember(ICompilerProject project,
            IDefinition nodeDef, IClassDefinition classDef)
    {
        IDefinition parentDef = nodeDef.getParent();
    	if (nodeDef.isInternal() && (!(parentDef instanceof ClassDefinition)))
    		return false;
    	
        return parentDef == classDef || (parentDef instanceof ClassDefinition && ((ClassDefinition)parentDef).isInstanceOf(classDef, project));
    }
    
    public static boolean writeE4xFilterNode(ICompilerProject project,
            JSSessionModel model, IExpressionNode node)
    {
    	if (!model.inE4xFilter) return false;
    	
        IDefinition nodeDef = node.resolve(project);

        IASNode parentNode = node.getParent();
//        ASTNodeID parentNodeId = parentNode.getNodeID();

        IASNode firstChild = parentNode.getChild(0);

//        final IClassDefinition thisClass = model.getCurrentClass();

//        boolean identifierIsMemberAccess = parentNodeId == ASTNodeID.MemberAccessExpressionID;

        if (parentNode instanceof IUnaryOperatorNode)
        	return false;
        if (nodeDef instanceof ParameterDefinition)
            return false;
        if (nodeDef instanceof InterfaceDefinition)
            return false;
        if (nodeDef instanceof ClassDefinition)
            return false;
        if (nodeDef instanceof VariableDefinition)
        {
        		List<IVariableNode> list = model.getVars();
        		for (IVariableNode element : list) {
        		    if(element.getQualifiedName().equals(((IIdentifierNode)node).getName()))
        		    		return false;
        		}
        }
        
        if (node == firstChild) 
        		return true;
        //support alternate ordering of checks, e.g. listItem.(3 == @id) as well as the normal listItem.(@id == 3)
        if (parentNode instanceof IBinaryOperatorNode
            && node == parentNode.getChild(1)) {
            return !(parentNode instanceof IMemberAccessExpressionNode);
        }
        
        return false;
    }
    
   /* public static ArrayList<String> amendE4XFilterComparison(ICompilerProject project,
                                                     JSSessionModel model, IBinaryOperatorNode node, boolean isLeft) {
        if (!model.inE4xFilter) return null;
        IExpressionNode leftNode = node.getLeftOperandNode();
        IDefinition left = null;
        IDefinition right = null;
        boolean leftNodeMember = false;
        boolean leftNodeQName = false;
        boolean rightNodeMember = false;
        boolean rightNodeQName = false;
        if (writeE4xFilterNode(project, model, leftNode)) {
            leftNodeMember = true;
            if (leftNode  instanceof IFunctionCallNode &&
                    ((IFunctionCallNode) leftNode).getNameNode() != null){
                leftNodeQName = ((IFunctionCallNode) leftNode).getNameNode().equals("name");
            }
        } else {
            left = node.getLeftOperandNode().resolveType(project);
        }
        IExpressionNode rightNode = node.getRightOperandNode();
        if (writeE4xFilterNode(project, model, rightNode)) {
            rightNodeMember = true;
            if (rightNode  instanceof IFunctionCallNode &&
                    ((IFunctionCallNode) rightNode).getNameNode() != null){
                rightNodeQName = ((IFunctionCallNode) rightNode).getNameNode().equals("name");
            }
        } else {
            right = node.getRightOperandNode().resolveType(project);
        }
        if (!leftNodeMember && !rightNodeMember) return null;
        ArrayList<String> s = null;
        if (leftNodeMember) {
            //left side is a node.something() function
            if (right!= null && leftNodeQName) {
                //node.name() == right
                if (right.getQualifiedName().equals("String")) {
                    if (isLeft) {
                        s=new ArrayList<String>();
                        s.add(".toString()");
                    } //else make no change for right side
                } else if (rightNodeQName || right.getQualifiedName().equals("QName")) {
                    //use qname.equals(otherQName)
                    if (isLeft) {
                        s.add(".equals(");
                    } else {
                        s.add(")"); //close the equals
                    }
                }
            }
        }
        if (s == null && rightNodeMember) {
            //right side is a node.something() function that has not already been addressed
            if (left!= null && rightNodeQName) {
                //left == node.name()
                if (left.getQualifiedName().equals("String")) {
                    if (!isLeft) {
                        //node.name().toString()
                        s=new ArrayList<String>();
                        s.add(".toString()");
                    } //else make no change for right side
                } else if (rightNodeQName || right.getQualifiedName().equals("QName")) {
                    //use qname.equals(otherQName)
                    if (isLeft) {
                        s.add(".equals(");
                    } else {
                        s.add(")"); //close the equals
                    }
                }
            }
        }
       
        
        return s;
    }*/

    public static boolean isScalar(IExpressionNode node)
    {
    	ASTNodeID id = node.getNodeID();
        if (id == ASTNodeID.LiteralBooleanID ||
        		id == ASTNodeID.LiteralIntegerID ||
        		id == ASTNodeID.LiteralIntegerZeroID ||
        		id == ASTNodeID.LiteralDoubleID ||
        		id == ASTNodeID.LiteralNullID ||
        		id == ASTNodeID.LiteralNumberID ||
        		id == ASTNodeID.LiteralRegexID ||
        		id == ASTNodeID.LiteralStringID ||
        		id == ASTNodeID.LiteralUintID)
        	return true;
        if (id == ASTNodeID.IdentifierID)
        {
        	IIdentifierNode idnode = (IIdentifierNode)node;
        	String idname = idnode.getName();
        	if (idname.equals(NativeUtils.NativeASType.Infinity.name()) ||
        		idname.equals(NativeUtils.NativeASType.undefined.name()) ||
        		idname.equals(NativeUtils.NativeASType.NaN.name()))
        		return true;
        }
        // special case -Infinity
        if (id == ASTNodeID.Op_SubtractID &&
        		node.getChildCount() == 1)
        {
        	IASNode child = node.getChild(0);
        	if (child.getNodeID() == ASTNodeID.IdentifierID)
        	{
            	IIdentifierNode idnode = (IIdentifierNode)child;
            	String idname = idnode.getName();
            	if (idname.equals(NativeUtils.NativeASType.Infinity.name()))
            		return true;        		
        	}
        }
        return false;
    }

    // return true if the node is an expression that may not work
    // as the initial value of a static var at
    // static initialization time.  Such as a function call to
    // another static method in the class.
    // Non-static initializers have different rules: even simple object
    // and arrays need to be created for each instance, but for statics
    // simple objects and arras are ok.
    public static boolean needsStaticInitializer(String node, String className)
    {
    	return node.contains(className);
    }

    public static IContainerNode insertArgumentsBefore(IContainerNode argumentsNode, IASNode... nodes)
    {
        int originalLength = argumentsNode.getChildCount();
        int extraLength = nodes.length;
        ContainerNode result = new ContainerNode(originalLength + extraLength);
        result.setSourcePath(argumentsNode.getSourcePath());
        result.span(argumentsNode);
        result.setParent((NodeBase) argumentsNode.getParent());
        for (int i = 0; i < extraLength; i++)
        {
            NodeBase node = (NodeBase) nodes[i];
            node.setSourcePath(argumentsNode.getSourcePath());
            result.addItem(node);
        }
        for (int i = 0; i < originalLength; i++)
        {
            result.addItem((NodeBase) argumentsNode.getChild(i));
        }
        return result;
    }

    public static IContainerNode insertArgumentsAfter(IContainerNode argumentsNode, IASNode... nodes)
    {
        int originalLength = argumentsNode.getChildCount();
        int extraLength = nodes.length;
        ContainerNode result = new ContainerNode(originalLength + extraLength);
        result.setSourcePath(argumentsNode.getSourcePath());
        result.span(argumentsNode);
        result.setParent((NodeBase) argumentsNode.getParent());
        for (int i = 0; i < originalLength; i++)
        {
            result.addItem((NodeBase) argumentsNode.getChild(i));
        }
        for (int i = 0; i < extraLength; i++)
        {
            NodeBase node = (NodeBase) nodes[i];
            node.setSourcePath(argumentsNode.getSourcePath());
            result.addItem(node);
        }
        return result;
    }

    public static IContainerNode insertArgumentsAt(IContainerNode argumentsNode, int index, IASNode... nodes)
    {
        int originalLength = argumentsNode.getChildCount();
        int extraLength = nodes.length;
        ContainerNode result = new ContainerNode(originalLength + extraLength);
        result.setSourcePath(argumentsNode.getSourcePath());
        result.span(argumentsNode);
        result.setParent((NodeBase) argumentsNode.getParent());
        for (int i = 0; i < originalLength; i++)
        {
            if(i < index)
            {
                result.addItem((NodeBase) argumentsNode.getChild(i));
            }
            else
            {
            	if (i == index)
                {
                    for (IASNode node : nodes)
                    {
                    	NodeBase n = (NodeBase) node;
                    	n.setSourcePath(argumentsNode.getSourcePath());
                    	result.addItem(n);
                    }
                }
                result.addItem((NodeBase) argumentsNode.getChild(i));
            }
        }
        return result;
    }

    public static boolean isImplicit(IContainerNode node)
    {
        return node.getContainerType() == IContainerNode.ContainerType.IMPLICIT
                || node.getContainerType() == IContainerNode.ContainerType.SYNTHESIZED;
    }

    public static boolean needsDefaultValue(IVariableNode node, boolean defaultInitializers, ICompilerProject project)
    {
        if (node == null)
        {
            return false;
        }
        if (node instanceof IParameterNode)
        {
            return false;
        }
        if (node instanceof IAccessorNode)
        {
            return false;
        }
        IExpressionNode assignedValueNode = node.getAssignedValueNode();
        if (assignedValueNode != null)
        {
            //already has an assigned value, so it doesn't need to be
            //hoisted
            return false;
        }
        IASNode parentNode = node.getParent();
        if (parentNode instanceof IVariableExpressionNode)
        {
            //ignore for-in loops
            return false;
        }
        IExpressionNode variableTypeNode = node.getVariableTypeNode();
        if (variableTypeNode == null)
        {
            return false;
        }
        IDefinition varTypeDef = variableTypeNode.resolve(project);
        if (varTypeDef == null)
        {
            return false;
        }
        if (IASLanguageConstants.ANY_TYPE.equals(varTypeDef.getQualifiedName()))
        {
            return false;
        }
        if (project.getBuiltinType(BuiltinType.ANY_TYPE).equals(varTypeDef)
                || project.getBuiltinType(BuiltinType.ANY_TYPE).equals(varTypeDef)
                || project.getBuiltinType(BuiltinType.ANY_TYPE).equals(varTypeDef))
        {
            return false;
        }
        if (project.getBuiltinType(BuiltinType.INT).equals(varTypeDef)
                || project.getBuiltinType(BuiltinType.UINT).equals(varTypeDef))
        {
            //always true, regardless of -js-default-initializers
            return true;
        }
        return defaultInitializers;
    }
    
    
    /**
     * resolveType on an XML expression returns null
     * (see IdentiferNode.resolveType).
     * So, we have to walk the tree ourselves and resolve
     * individual pieces.
     * @param obj
     * @return
     */
    public static boolean isXMLish(IExpressionNode obj, ICompilerProject project )
    {
        // See if the left side is XML or XMLList
        IDefinition leftDef = obj.resolveType(project);
        if (leftDef == null && obj.getNodeID() == ASTNodeID.MemberAccessExpressionID)
        {
            return isXMLish(((MemberAccessExpressionNode)obj).getLeftOperandNode(), project);
        }
        else if (leftDef != null && leftDef.getBaseName().equals("*") && obj instanceof DynamicAccessNode) {
            return isXMLish(((DynamicAccessNode)obj).getLeftOperandNode(), project);
        }
        return SemanticUtils.isXMLish(leftDef, project);
    }
    
    
    /**
     * resolveType on an XML expression returns null
     * (see IdentiferNode.resolveType).
     * So, we have to walk the tree ourselves and resolve
     * individual pieces.
     * We want to know not just whether the node is of type XML,
     * but whether it is a property of a property of type XML.
     * For example, this.foo might be XML or XMLList, but since
     * 'this' isn't also XML, we return false.  That's because
     * assignment to this.foo shouldn't use setChild() but
     * just do an assignment.
     * @param obj
     * @return
     */
    public static boolean isXMLList(IMemberAccessExpressionNode obj, ICompilerProject project)
    {
        IExpressionNode leftNode = obj.getLeftOperandNode();
        IExpressionNode rightNode = obj.getRightOperandNode();
        ASTNodeID rightID = rightNode.getNodeID();
        if (rightID == ASTNodeID.IdentifierID || (rightID == ASTNodeID.NamespaceAccessExpressionID && rightNode.getChild(1).getNodeID() == ASTNodeID.IdentifierID))
        {
            IDefinition rightDef = rightNode.resolveType(project);
            if (rightDef != null)
            {
                //we can have an identifier of '*' which resolves to ANY_TYPE ClassDefinition and does not resolve as isXMLish, but the Member access expression is if the leftNode is xmlish
                boolean isAny = rightID == ASTNodeID.IdentifierID && ((IIdentifierNode) rightNode).getName().equals("*");
                if (isAny || SemanticUtils.isXMLish(rightDef, project))
                {
                    return isLeftNodeXMLish(leftNode, project);
                }
                return false;
            }
            return isLeftNodeXMLish(leftNode, project);
        }
        else if (rightID == ASTNodeID.Op_AtID)
            return true;
        else if (rightNode instanceof IDynamicAccessNode && ((IDynamicAccessNode) rightNode).getLeftOperandNode().getNodeID() == ASTNodeID.Op_AtID)
            return true;
        return false;
    }

    public static boolean isLeftNodeXMLList(IExpressionNode leftNode, ICompilerProject project) {
        boolean isXMLList = false;
        if (isLeftNodeXMLish(leftNode, project)) {
            //it is not XMLList if it is a DynamicAccessNode with numeric index.
            //this is limited analysis, because ["0"] would also be the same as [0], but perhaps best we can do without more runtime support
            if (leftNode instanceof IDynamicAccessNode) { //DynamicAccessNode
                IExpressionNode dynAccess = ((IDynamicAccessNode) leftNode).getRightOperandNode();
                IDefinition accessDef = dynAccess.resolveType(project);
                if (SemanticUtils.isNumericType(accessDef, project)) {
                    //assume we are XML, not XMLList
                    isXMLList = false;
                }
            } else
                isXMLList = true;

        }
        return isXMLList;
    }

    public static boolean isLeftNodeXML(IExpressionNode leftNode, ICompilerProject project) {
        boolean isXML = false;
        if (isLeftNodeXMLish(leftNode, project)) {
            //it is not XMLList if it is a DynamicAccessNode with numeric index.
            //this is limited analysis, because ["0"] would also be the same as [0], but perhaps best we can do without more runtime support
            if (leftNode instanceof IDynamicAccessNode) { //DynamicAccessNode
                IExpressionNode dynAccess = ((IDynamicAccessNode) leftNode).getRightOperandNode();
                IDefinition accessDef = dynAccess.resolveType(project);
                if (SemanticUtils.isNumericType(accessDef, project)) {
                    //assume we are XML, not XMLList
                    isXML = true;
                }
            } else
                isXML = false;

        }
        return isXML;
    }
    
    
    public static boolean isLeftNodeXMLish(IExpressionNode leftNode, ICompilerProject project)
    {
        ASTNodeID leftID = leftNode.getNodeID();
        if (leftID == ASTNodeID.IdentifierID)
        {
            IDefinition leftDef = leftNode.resolveType(project);
            if (leftDef != null)
                return SemanticUtils.isXMLish(leftDef, project);
        }
        else if (leftID == ASTNodeID.MemberAccessExpressionID || leftID == ASTNodeID.Op_DescendantsID)
        {
            MemberAccessExpressionNode maen = (MemberAccessExpressionNode)leftNode;
            IExpressionNode rightNode = maen.getRightOperandNode();
            ASTNodeID rightID = rightNode.getNodeID();
            if (rightID == ASTNodeID.IdentifierID)
            {
                IDefinition rightDef = rightNode.resolveType(project);
                if (rightDef != null && rightDef != project.getBuiltinType(BuiltinType.ANY_TYPE))
                {
                    return SemanticUtils.isXMLish(rightDef, project);
                }
            }
            leftNode = maen.getLeftOperandNode();
            return isLeftNodeXMLish(leftNode, project);
        }
        else if (leftID == ASTNodeID.FunctionCallID)
        {
            FunctionCallNode fcn = (FunctionCallNode)leftNode;
            String fname = fcn.getFunctionName();
            if (fname.equals("XML") || fname.equals("XMLList"))
                return true;
        }
        else if (leftID == ASTNodeID.Op_AsID)
        {
            BinaryOperatorAsNode boan = (BinaryOperatorAsNode)leftNode;
            String fname = ((IdentifierNode)boan.getChild(1)).getName();
            if (fname.equals("XML") || fname.equals("XMLList"))
                return true;
        }
        else if (leftID == ASTNodeID.ArrayIndexExpressionID)
        {
            leftNode = (IExpressionNode)(leftNode.getChild(0));
            IDefinition leftDef = leftNode.resolveType(project);
            if (leftDef != null)
                return SemanticUtils.isXMLish(leftDef, project);
            
        }
        else if (leftID == ASTNodeID.E4XFilterID)
            return true;
        return false;
    }
    
    public static boolean needsXMLQNameArgumentsPatch(IFunctionCallNode node, ICompilerProject project) {
        if (node.getNameNode() instanceof MemberAccessExpressionNode
        && ((MemberAccessExpressionNode)node.getNameNode()).getRightOperandNode() instanceof IdentifierNode) {
            String methodName = ((IdentifierNode)((MemberAccessExpressionNode)node.getNameNode()).getRightOperandNode()).getName();
            if ("child".equals(methodName) || "descendants".equals(methodName) || "attribute".equals(methodName)) {
                //double check it is not a method with the same name on a non-XMLish class
                IASNode leftNode = ((MemberAccessExpressionNode)node.getNameNode()).getLeftOperandNode();
                boolean isXML = leftNode instanceof MemberAccessExpressionNode
                        && isLeftNodeXMLish((MemberAccessExpressionNode) leftNode, project);
                if (!isXML) {
                    isXML = leftNode instanceof IExpressionNode && isXMLish((IExpressionNode)leftNode, project);
                }
                if (isXML) {
                    //check argumentsNode
                    if (node.getArgumentsNode().getChildCount() == 1) {
                        IDefinition def = node.getArgumentNodes()[0].resolveType(project);
                        if (def != null && def.getQualifiedName().equals("QName")) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    
    public static void createDefaultNamespaceArg(ContainerNode argsNode, int position, IExpressionNode defaultNamespace) {
        argsNode.addChild((NodeBase) defaultNamespace, position);
        ((NodeBase) defaultNamespace).setParent(argsNode);
    }
    
    public static boolean isCustomNamespace(String ns) {
        if (ns != null)
        {
            return (!(  ns.equals(IASKeywordConstants.PRIVATE) ||
                        ns.equals(IASKeywordConstants.PROTECTED) ||
                        ns.equals(IASKeywordConstants.INTERNAL) ||
                        ns.equals(INamespaceConstants.AS3URI) ||
                        ns.equals(IASKeywordConstants.PUBLIC)
                    ));
        }
        return false;
    }

    public static final String getClassDepthNameBase(String base, IClassDefinition definition, ICompilerProject project) {
        return base + "_" + DefinitionUtils.deltaFromObject(definition, project) +"_";
    }

    public static final FunctionCallNode wrapXMLListStringCoercion(NodeBase orig) {
        //create a call to XMLList.coerce_string(orig)
        IdentifierNode xmllistClassRef = new IdentifierNode(IASLanguageConstants.XMLList);
        IdentifierNode castMethod = new IdentifierNode("coerce_string");

        MemberAccessExpressionNode castNode = new MemberAccessExpressionNode(xmllistClassRef,null, castMethod);
        xmllistClassRef.setParent(castNode);
        castMethod.setParent(castNode);
        FunctionCallNode stringCast = new FunctionCallNode(castNode);
        //explicit parent setting for name and arguments:
        castNode.setParent(stringCast);
        stringCast.getArgumentsNode().setParent(stringCast);
        //wrap the original node
        stringCast.getArgumentsNode().addItem((NodeBase) orig);
        return stringCast;
    }


    public static final FunctionCallNode wrapSimpleStringCoercion(NodeBase orig) {
        //create a call to String(orig)
        IdentifierNode castNode = new IdentifierNode(IASLanguageConstants.String);
        FunctionCallNode stringCast = new FunctionCallNode(castNode);
        //explicit parent setting for name and arguments:
        castNode.setParent(stringCast);
        stringCast.getArgumentsNode().setParent(stringCast);
        //wrap the original node
        stringCast.getArgumentsNode().addItem((NodeBase) orig);
        return stringCast;
    }

    public static final boolean xmlRequiresNullCheck(NodeBase orig, ICompilerProject project) {
        boolean ret = false;
        if (orig instanceof IIdentifierNode) {
            ret = true;
        } else if (orig instanceof IBinaryOperatorNode) {
            //should cover IDynamicAccessNode and IMemberAccessExpressionNode
            //if the left node is xmlish, then we don't need null check
            ret = !isLeftNodeXMLish(((IBinaryOperatorNode) orig).getLeftOperandNode(),project);
        }

        return ret;
    }

}
