public Object visit(NewArrayExpression node) {
            ExpressionList list = node.getExpressionList();
            Expression[] exprs = list.getExpressions();

            Type initialType = node.getInitialType();
            Class<?> initialClass = initialType.getObjectClass();

            // Check if this array is composed entirely of constants,
            // and if so, make the array a static field, and populate
            // it in a static initializer.
            if (mAllowInitializerStatements && node.isAllConstant()) {
                SourceInfo info = node.getSourceInfo();

                // Create a variable...
                Variable var = new Variable(info, "array", initialType);
                var.setStatic(true);
                generate(var);
                // Create an assignment statement...
                VariableRef ref = new VariableRef(info, "array");
                ref.setVariable(var);

                // Clone the NewArrayExpression so that the type can be
                // changed back to the underlying array type. This prevents
                // unecessary casting in the assignment statement.
                Expression clonedNode = (Expression)node.clone();
                clonedNode.setType(initialType);

                AssignmentStatement assn =
                    new AssignmentStatement(info, ref, clonedNode);

                // Move this statement into the static initializer
                mInitializerStatements.add(assn);

                // Substitute a field access for a NewArrayExpression
                TypeDesc td = makeDesc(initialClass);
                mBuilder.loadStaticField(var.getName(), td);
            }
            else if (node.isAssociative()) {
                // Constuct LinkedHashMap to support associative array.
                TypeDesc td = makeDesc(LinkedHashMap.class);
                mBuilder.newObject(td);
                mBuilder.dup();

                int capacity = exprs.length;
                if (capacity == 0) {
                    // Should probably use a JDK1.3 EMPTY_MAP, and not wrap
                    // with unmodifiableMap.
                }
                else if (capacity == 2) {
                    // Should probably use a JDK1.3 singletonMap, and not wrap
                    // with unmodifiableMap.
                    capacity = 1;
                }
                else {
                    // Initial capacity at least 2n + 1.
                    BigInteger cap = BigInteger.valueOf(capacity + 1);
                    // Ensure capacity is prime to reduce hash collisions.
                    while (!cap.isProbablePrime(100)) {
                        cap = cap.add(BigInteger.valueOf(2));
                    }
                    capacity = cap.intValue();
                }

                mBuilder.loadConstant(capacity);
                mBuilder.invokeConstructor
                    (LinkedHashMap.class.getName(), cIntParam);

                Method putMethod;
                try {
                    putMethod = LinkedHashMap.class.getMethod
                        ("put", new Class[] {Object.class, Object.class});
                }
                catch (NoSuchMethodException e) {
                    throw new RuntimeException(e.toString());
                }

                boolean doPop = (putMethod.getReturnType() != void.class);

                // Perform put operations to populate the Map.
                for (int i = 0; i < exprs.length; i += 2) {
                    mBuilder.dup(); // duplicate the Map
                    generate(exprs[i]); // generate the key
                    generate(exprs[i + 1]); // generate the value
                    mBuilder.invoke(putMethod);
                    if (doPop) {
                        mBuilder.pop();
                    }
                }

                // Prevent map modification by rogue Java functions.
                if (node.isAllConstant()) {
                    try {
                        Method unmodifiable = Collections.class.getMethod
                            ("unmodifiableMap", new Class[] {Map.class});
                        mBuilder.invoke(unmodifiable);
                    }
                    catch (NoSuchMethodException e) {
                    }
                }
            }
            else {
                Class<?> componentClass = initialClass.getComponentType();
                TypeDesc componentType = makeDesc(componentClass);

                mBuilder.loadConstant(exprs.length);
                mBuilder.newObject(componentType.toArrayType());

                // Populate the array.
                for (int i=0; i<exprs.length; i++) {
                    Expression expr = exprs[i];
                    if (expr.isValueKnown()) {
                        // Check if expression value is the same as the default
                        // for values in a newly initialized array.

                        Object value = expr.getValue();
                        Type type = expr.getType();
                        if (!type.isPrimitive()) {
                            if (value == null) {
                                continue;
                            }
                        }
                        else {
                            if (value instanceof Number) {
                                if (((Number)value).doubleValue() == 0) {
                                    continue;
                                }
                            }
                            else if (value instanceof Boolean) {
                                if (((Boolean)value).booleanValue() == false) {
                                    continue;
                                }
                            }
                        }
                    }

                    mBuilder.dup();
                    mBuilder.loadConstant(i);
                    generate(expr);
                    mBuilder.storeToArray(componentType);
                }
            }

            return null;
        }