
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
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);
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy