org.mozilla.javascript.ast.ArrayLiteral Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rhino-runtime Show documentation
Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically embedded into Java applications to provide scripting to end users.
The newest version!
/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.mozilla.javascript.ast;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.mozilla.javascript.Token;

/**
 * AST node for an Array literal. The elements list will always be non-{@code null}, although the
 * list will have no elements if the Array literal is empty.
 *
 * Node type is {@link Token#ARRAYLIT}.
 *
 * 
ArrayLiteral :
 *        [ Elisionopt ]
 *        [ ElementList ]
 *        [ ElementList , Elisionopt ]
 * ElementList :
 *        Elisionopt AssignmentExpression
 *        ElementList , Elisionopt AssignmentExpression
 * Elision :
 *        ,
 *        Elision ,
 */
public class ArrayLiteral extends AstNode implements DestructuringForm {

    private static final List NO_ELEMS = Collections.unmodifiableList(new ArrayList<>());

    private List elements;
    private int destructuringLength;
    private int skipCount;
    private boolean isDestructuring;

    {
        type = Token.ARRAYLIT;
    }

    public ArrayLiteral() {}

    public ArrayLiteral(int pos) {
        super(pos);
    }

    public ArrayLiteral(int pos, int len) {
        super(pos, len);
    }

    /**
     * Returns the element list
     *
     * @return the element list. If there are no elements, returns an immutable empty list. Elisions
     *     are represented as {@link EmptyExpression} nodes.
     */
    public List getElements() {
        return elements != null ? elements : NO_ELEMS;
    }

    /**
     * Sets the element list, and sets each element's parent to this node.
     *
     * @param elements the element list. Can be {@code null}.
     */
    public void setElements(List elements) {
        if (elements == null) {
            this.elements = null;
        } else {
            if (this.elements != null) this.elements.clear();
            for (AstNode e : elements) addElement(e);
        }
    }

    /**
     * Adds an element to the list, and sets its parent to this node.
     *
     * @param element the element to add
     * @throws IllegalArgumentException if element is {@code null}. To indicate an empty element,
     *     use an {@link EmptyExpression} node.
     */
    public void addElement(AstNode element) {
        assertNotNull(element);
        if (elements == null) elements = new ArrayList<>();
        elements.add(element);
        element.setParent(this);
    }

    /** Returns the number of elements in this {@code Array} literal, including empty elements. */
    public int getSize() {
        return elements == null ? 0 : elements.size();
    }

    /**
     * Returns element at specified index.
     *
     * @param index the index of the element to retrieve
     * @return the element
     * @throws IndexOutOfBoundsException if the index is invalid
     */
    public AstNode getElement(int index) {
        if (elements == null) throw new IndexOutOfBoundsException("no elements");
        return elements.get(index);
    }

    /** Returns destructuring length */
    public int getDestructuringLength() {
        return destructuringLength;
    }

    /**
     * Sets destructuring length. This is set by the parser and used by the code generator. {@code
     * for ([a,] in obj)} is legal, but {@code for ([a] in obj)} is not since we have both key and
     * value supplied. The difference is only meaningful in array literals used in
     * destructuring-assignment contexts.
     */
    public void setDestructuringLength(int destructuringLength) {
        this.destructuringLength = destructuringLength;
    }

    /**
     * Used by code generator.
     *
     * @return the number of empty elements
     */
    public int getSkipCount() {
        return skipCount;
    }

    /**
     * Used by code generator.
     *
     * @param count the count of empty elements
     */
    public void setSkipCount(int count) {
        skipCount = count;
    }

    /**
     * Marks this node as being a destructuring form - that is, appearing in a context such as
     * {@code for ([a, b] in ...)} where it's the target of a destructuring assignment.
     */
    @Override
    public void setIsDestructuring(boolean destructuring) {
        isDestructuring = destructuring;
    }

    /**
     * Returns true if this node is in a destructuring position: a function parameter, the target of
     * a variable initializer, the iterator of a for..in loop, etc.
     */
    @Override
    public boolean isDestructuring() {
        return isDestructuring;
    }

    @Override
    public String toSource(int depth) {
        StringBuilder sb = new StringBuilder();
        sb.append(makeIndent(depth));
        sb.append("[");
        if (elements != null) {
            printList(elements, sb);
        }
        sb.append("]");
        return sb.toString();
    }

    /**
     * Visits this node, then visits its element expressions in order. Any empty elements are
     * represented by {@link EmptyExpression} objects, so the callback will never be passed {@code
     * null}.
     */
    @Override
    public void visit(NodeVisitor v) {
        if (v.visit(this)) {
            for (AstNode e : getElements()) {
                e.visit(v);
            }
        }
    }
}