v.AddArgs(fields[:n]...)

	// Recursively decompose phis for each field.
	for _, f := range fields[:n] {
		decomposeUserPhi(f)
	}
}

// decomposeArrayPhi replaces phi-of-array with arraymake(phi-of-array-element),
// and then recursively decomposes the element phi.
func decomposeArrayPhi(v *Value) {
	t := v.Type
	if t.NumElem() == 0 {
		v.reset(OpArrayMake0)
		return
	}
	if t.NumElem() != 1 {

    @Override
    public boolean equals(final Object o) {
        if (o == null) {
            return false;
        }
        if (!(o instanceof ArrayMap)) {
            return false;
        }
        @SuppressWarnings("unchecked")
        final ArrayMap<K, V> e = (ArrayMap<K, V>) o;
        if (size != e.size) {
            return false;
        }
        for (int i = 0; i < size; i++) {

        exception.expectMessage(is("Index:1, Size:0"));
        ArrayMap<String, String> m = new ArrayMap<String, String>(1);
        m.getEntryAt(1);
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSerialize() throws Exception {
        @SuppressWarnings("unchecked")
        ArrayMap<String, String> copy = (ArrayMap<String, String>) SerializeUtil.serialize(map);

        f1
        (Store {t.FieldType(0)}
          (OffPtr <t.FieldType(0).PtrTo()> [0] dst)
            f0 mem))))

(ArraySelect (ArrayMake1 x)) => x
(ArraySelect [0] (IData x)) => (IData x)

(Store dst (ArrayMake1 e) mem) => (Store {e.Type} dst e mem)

// NOTE removed must-not-be-SSA condition.
(ArraySelect [i] x:(Load <t> ptr mem)) =>

				notOK()
				println(desc, " unexpected panic: ", fmt.Sprint(err))
			}
		}
		// "no panic" is checked below
	}()
	
	x := f()

	arrayBase := uintptr(unsafe.Pointer(array))
	raw := *(*[3]uintptr)(unsafe.Pointer(&x))
	base, len, cap := raw[0] - arrayBase, raw[1], raw[2]
	if xbase < 0 {
		notOK()
		println(desc, "=", base, len, cap, "want panic")
		return
	}

        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override
        @ParametricNullness
        public V setValue(@ParametricNullness V value) {
          return ArrayMap.this.setValue(index, value);
        }
      };

 */
package org.codelibs.core.collection;

import java.util.Map;

/**
 * キーで大文字小文字を気にしない {@link ArrayMap}です。
 *
 * @author higa 値の型
 * @param <V>
 *            値の型
 */
public class CaseInsensitiveMap<V> extends ArrayMap<String, V> {

    private static final long serialVersionUID = 1L;

    /**
     * {@link CaseInsensitiveMap}を作成します。
     */

        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override
        @ParametricNullness
        public V setValue(@ParametricNullness V value) {
          return ArrayMap.this.setValue(index, value);
        }
      };

    protected final CaseInsensitiveMap<PropertyDesc> propertyDescCache = new CaseInsensitiveMap<>();

    /** フィールド名から{@link FieldDescImpl}へのマップ */
    protected final ArrayMap<String, FieldDesc> fieldDescCache = new ArrayMap<>();

    /** {@link ConstructorDesc}の配列 */
    protected final List<ConstructorDesc> constructorDescs = newArrayList();

    /** メソッド名から{@link MethodDesc}配列へのマップ */

		return rewriteValuedec_OpStructMake1(v)
	case OpStructSelect:
		return rewriteValuedec_OpStructSelect(v)
	}
	return false
}
func rewriteValuedec_OpArrayMake1(v *Value) bool {
	v_0 := v.Args[0]
	// match: (ArrayMake1 x)
	// cond: x.Type.IsPtrShaped()
	// result: x
	for {
		x := v_0
		if !(x.Type.IsPtrShaped()) {
			break
		}
		v.copyOf(x)
		return true
	}
	return false
}