delegate.visibleParameterAnnotations?.map { it.has<Nullable>() }.let { parametersNullability ->
        val parameterTypesBinaryNames = visitedSignature?.parameters?.map { if (it.isArray) "${it.typeArguments.single().binaryName}[]" else it.binaryName }
            ?: Type.getArgumentTypes(delegate.desc).map { it.className }
        val names by unsafeLazy {
            parameterNamesFor(

    }

    private
    fun Type.toCodeTypeString(): String {
        if (this is Class<*> && this.isArray) {
            return this.componentType.toCodeTypeString() + "[]"
        }
        return toString()
            .replace("class ", "")
            .replace("interface ", "")
    }

      }
      final Class<?> returnType = method.getReturnType();
      assertTrue(
          rootLocaleFormat("%s.%s() must return an array.", annotationClass, propertyName),
          returnType.isArray());
      assertSame(
          rootLocaleFormat(
              "%s.%s() must return an array of %s.",
              annotationClass, propertyName, annotationClass.getDeclaringClass()),

     * @return The string representation, never <code>null</code>.
     */
    private String toString(Object obj) {
        String str;
        if (obj != null && obj.getClass().isArray()) {
            int n = Array.getLength(obj);
            StringBuilder buf = new StringBuilder(256);
            buf.append('[');
            for (int i = 0; i < n; i++) {
                if (i > 0) {

    private
    fun signatureOf(method: JavaMethod): String =
        method.parameters.joinToString(separator = ",") { p ->
            if (p.isVarArgs || p.javaClass.isArray) "${p.type.binaryName}[]"
            else p.type.binaryName
        }

    private
    fun commaSeparatedParameterNamesOf(method: JavaMethod) =
        method.parameters.joinToString(separator = ",") { it.name }

      }
      final Class<?> returnType = method.getReturnType();
      assertTrue(
          rootLocaleFormat("%s.%s() must return an array.", annotationClass, propertyName),
          returnType.isArray());
      assertSame(
          rootLocaleFormat(
              "%s.%s() must return an array of %s.",
              annotationClass, propertyName, annotationClass.getDeclaringClass()),

        return !((OptionalDouble) value).isPresent();
      } else if (value instanceof Optional) {
        return !((Optional) value).isPresent();
      } else if (value.getClass().isArray()) {
        return Array.getLength(value) == 0;
      }
      return false;
    }

    /**
     * Returns a string in the format specified by {@link MoreObjects#toStringHelper(Object)}.
     *

     *
     * @param object
     *            オブジェクト
     * @return オブジェクトが配列の場合は{@literal true}。{@literal null}の場合は{@literal false}
     */
    public static boolean isArray(final Object object) {
        return object != null && object.getClass().isArray();
    }

    /**
     * オブジェクトが配列でない場合は{@literal true}を返します。{@literal null}の場合は{@literal true}
     * を返します。
     *
     * @param object

		return true
	}
	return false
}

// IsMissing - checks if value is missing.
func (v Value) IsMissing() bool {
	_, ok := v.value.(Missing)
	return ok
}

// IsArray returns whether the value is an array.
func (v Value) IsArray() (ok bool) {
	_, ok = v.value.([]Value)
	return ok
}

func (v Value) isNumeric() bool {
	//nolint:gocritic
	switch v.value.(type) {
	case int64, float64:

                oldValues = ((Collection<?>) oldValue).toArray();
            } else {
                oldValues = new Object[] { oldValue };
            }
            if (value.getClass().isArray()) {
                final Object[] newValues = (Object[]) value;
                final Object[] values = Arrays.copyOf(oldValues, oldValues.length + newValues.length);
                for (int i = 0; i < newValues.length; i++) {