For array types, the previous implementation used the element name.
495813
protected ClassInfoImpl getDelayableClassInfo(Type type) {
        String typeClassName = type.getClassName();

        if (tc.isDebugEnabled()) {
            // Type 'toString' answers the descriptor;
            // show the type class name, too, for clarity.

            Tr.debug(tc, MessageFormat.format("[ {0} ] ENTER [ {1} ] [ {2} ]",
                                              new Object[] { getHashText(), type, typeClassName }));
        }

        // Now that we have the type class name, pass it along instead
        // of recomputing when needed.

        ClassInfoImpl classInfo;
        String classInfoCase;

        int sort = type.getSort();
        if (sort == Type.ARRAY) {
            classInfo = getArrayClassInfo(typeClassName, type);
            classInfoCase = "array class";

        } else if (sort == Type.OBJECT) {
            classInfo = getDelayableClassInfo(typeClassName, DO_NOT_ALLOW_PRIMITIVE);

            if (classInfo.isJavaClass()) {
                if (classInfo.isDelayedClass()) {
                    classInfoCase = "java delayed";
                } else {
                    classInfoCase = "java non-delayed";
                }
            } else {
                if (classInfo.isDelayedClass()) {
                    classInfoCase = "non-java delayed";
                } else {
                    classInfoCase = "non-java non-delayed";
                }
            }

        } else {
            classInfo = getPrimitiveClassInfo(typeClassName, type);
            classInfoCase = "primitive class";
        }

        if (tc.isDebugEnabled()) {
            Tr.debug(tc, MessageFormat.format("[ {0} ] RETURN [ {1} ] [ {2} ]",
                                              new Object[] { getHashText(),
                                                            classInfo.getHashText(),
                                                            classInfoCase }));
        }
        return classInfo;
    }
64394
public <T> T[] nextArray(@NonNull Class<T> elementType) throws IOException {
      return nextArray(StringUtils.EMPTY, elementType);
   }
1336221
function Array_includes(searchElement, // @arg Any
                        position) {    // @arg Integer = 0
                                       // @ret Boolean
    position = position || 0;
    var iz = this.length;

    if (iz === 0) {
        return false;
    }

    var i = 0;

    if (position >= 0) {
        i = position;
    } else {
        i = position + iz;
        if (i < 0) {
            i = 0;
        }
    }

    if (searchElement === searchElement) {
        for (; i < iz; ++i) {
            if (this[i] === searchElement) {
                return true;
            }
        }
    } else if (isNaN(searchElement)) {
        for (; i < iz; ++i) {
            if (isNaN(this[i])) {
                return true;
            }
        }
    } else { // maybe Symble, ... etc
        throw TypeError("Unsupported type");
    }
    return false;
}
1100618
public String beginArray() throws IOException {
      String name = null;
      if (currentValue.getKey() == NAME) {
         name = currentValue.getValue().asString();
         consume();
      }
      if (currentValue.getKey() == BEGIN_ARRAY) {
         consume();
      } else if (readStack.peek() != BEGIN_ARRAY) {
         throw new IOException("Expecting BEGIN_ARRAY, but found " + jsonTokenToStructuredElement(null));
      }
      return name;
   }
744591
@Nonnull
  @MayContainNull
  @Weight(Weight.Unit.NORMAL)
  public static <T> T[] append(@Nullable final T element, @MayContainNull @Nonnull final T[] array) {
    @SuppressWarnings("unchecked")
    final T[] result = (T[]) Array.newInstance(array.getClass().getComponentType(), array.length + 1);
    System.arraycopy(array, 0, result, 1, array.length);
    result[0] = element;
    return result;
  }
1221893
@SuppressWarnings("unchecked")
	public static <T> Object insert(Object array, int index, T... newElements) {
		if (isEmpty(newElements)) {
			return array;
		}
		if(isEmpty(array)) {
			return newElements;
		}
		
		final int len = length(array);
		if (index < 0) {
			index = (index % len) + len;
		}
		
		final T[] result = newArray(array.getClass().getComponentType(), Math.max(len, index) + newElements.length);
		System.arraycopy(array, 0, result, 0, Math.min(len, index));
		System.arraycopy(newElements, 0, result, index, newElements.length);
		if (index < len) {
			System.arraycopy(array, index, result, index + newElements.length, len - index);
		}
		return result;
	}
368007
@SafeVarargs
	public static <T> T[] addAll(T[]... arrays) {
		if (arrays.length == 1) {
			return arrays[0];
		}

		int length = 0;
		for (T[] array : arrays) {
			if (array == null) {
				continue;
			}
			length += array.length;
		}
		T[] result = newArray(arrays.getClass().getComponentType().getComponentType(), length);

		length = 0;
		for (T[] array : arrays) {
			if (array == null) {
				continue;
			}
			System.arraycopy(array, 0, result, length, array.length);
			length += array.length;
		}
		return result;
	}
1203444
@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public PrefixedPropertiesEnumeration<Object> elements() {
		lock.readLock().lock();
		try {
			final Collection values = values();
			final Iterator it = values.iterator();
			return new PrefixedPropertiesEnumerationImpl(it);
		} finally {
			lock.readLock().unlock();
		}
	}
141590
function(type) {
			var result = [],
				spirit, el = this.spirit.element;
			while ((el = el.previousElementSibling)) {
				if (type && (spirit = el.spirit)) {
					if (spirit instanceof type) {
						result.push(spirit);
					}
				} else {
					result.push(el);
				}
			}
			return result;
		}
899422
void compareArrayTypes(Schema oldSchema,
                                                Schema newSchema,
                                                List<Message> messages,
                                                String name) {
        if(oldSchema == null || newSchema == null || oldSchema.getType() != Schema.Type.ARRAY) {
            throw new IllegalArgumentException("Old schema must be ARRAY type. Name=" + name
                                               + ". Type=" + oldSchema);
        }

        if(newSchema.getType() != Schema.Type.ARRAY) {
            messages.add(new Message(Level.ERROR, "Illegal type change from " + oldSchema.getType()
                                                  + " to " + newSchema.getType() + " for field "
                                                  + name));
            return;
        }

        // Compare the array element types
        compareTypes(oldSchema.getElementType(),
                     newSchema.getElementType(),
                     messages,
                     name + ".<array element>");
    }
242301
function ArrayType (data, length) {
    if (!(this instanceof ArrayType)) {
      return new ArrayType(data, length)
    }
    debug('creating new array instance')
    ArrayIndex.call(this)
    var item_size = ArrayType.BYTES_PER_ELEMENT
    if (0 === arguments.length) {
      // new IntArray()
      // use the "fixedLength" if provided, otherwise throw an Error
      if (fixedLength > 0) {
        this.length = fixedLength
        this.buffer = new Buffer(this.length * item_size)
      } else {
        throw new Error('A "length", "array" or "buffer" must be passed as the first argument')
      }
    } else if ('number' == typeof data) {
      // new IntArray(69)
      this.length = data
      this.buffer = new Buffer(this.length * item_size)
    } else if (isArray(data)) {
      // new IntArray([ 1, 2, 3, 4, 5 ], {len})
      // use optional "length" if provided, otherwise use "fixedLength, otherwise
      // use the Array's .length
      var len = 0
      if (null != length) {
        len = length
      } else if (fixedLength > 0) {
        len = fixedLength
      } else {
        len = data.length
      }
      if (data.length < len) {
        throw new Error('array length must be at least ' + len + ', got ' + data.length)
      }
      this.length = len
      this.buffer = new Buffer(len * item_size)
      for (var i = 0; i < len; i++) {
        this[i] = data[i]
      }
    } else if (Buffer.isBuffer(data)) {
      // new IntArray(Buffer(8))
      var len = 0
      if (null != length) {
        len = length
      } else if (fixedLength > 0) {
        len = fixedLength
      } else {
        len = data.length / item_size | 0
      }
      var expectedLength = item_size * len
      this.length = len
      if (data.length != expectedLength) {
        if (data.length < expectedLength) {
          throw new Error('buffer length must be at least ' + expectedLength + ', got ' + data.length)
        } else {
          debug('resizing buffer from %d to %d', data.length, expectedLength)
          data = data.slice(0, expectedLength)
        }
      }
      this.buffer = data
    }
  }
155358
@SafeVarargs
  public static <E> RubyArray<E> newRubyArray(E... elements) {
    return new RubyArray<>(new ArrayList<>(Arrays.asList(elements)));
  }
1163238
public void addAll( T[] array , int first , int length ) {
		if( length <= 0 )
			return;

		Element<T> a = requestNew();
		a.object = array[first];

		if( this.first == null ) {
			this.first = a;
		} else if( last != null ) {
			last.next = a;
			a.previous = last;
		}

		for (int i = 1; i < length; i++) {
			Element<T> b = requestNew();
			b.object =  array[first+i];

			a.next = b;
			b.previous = a;
			a = b;
		}

		last = a;
		size += length;
	}
25656
@SuppressWarnings("unchecked")
    public static <T> T[] newArray(final T[] oldElements, final int length)
    {
        return (T[])Array.newInstance(oldElements.getClass().getComponentType(), length);
    }
964844
void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
        Type type = node.getType();
        if (node instanceof MethodDeclaration && ("newBufferAndOffset".equals(name) || "nextArrayOffset".equals(name))) {
            node.setType(PrimitiveType.intType());
        } else if (PrimitiveType.longType().equals(type)) {
            switch(name) {
            case "offset":
            case "offsetInNew":
            case "offsetInOld":
            case "lookAheadElementOffset":
                node.setType(PrimitiveType.intType());
            }
        } else if (isRefType(type, "LinkedQueueNode")) {
            node.setType(simpleParametricType("LinkedQueueAtomicNode", "E"));
        } else if (isRefArray(type, "E")) {
            node.setType(atomicRefArrayType((ArrayType) type));
        }
    }
1359276
function getNumElementsFromNonIndexedArrays(arrays) {
    var key = Object.keys(arrays)[0];
    var array = arrays[key];
    if (isArrayBuffer(array)) {
      return array.numElements;
    } else {
      return array.data.length / array.numComponents;
    }
  }
50350
public Object nextElement() 
    {
        if (_array == null)
        {
            return null;
        }
        else
        {
            synchronized(this){
                if (_index < _array.length)
                {
                    Object obj = _array[_index];
                    _index++;
                    return obj;
                }
                else
                {
                    return null;
                }
            }
        }
    }