Yan Zhulanow <******@****.***> 1713282657 +0900

Yan Zhulanow <******@****.***> 1713282657 +0900

    }

    private TestFile withRunWorkTaskOfPrimitiveArrayListProperty(IsolationMode isolationMode, String primitiveType) {
        def fixture = KotlinPrimitiveArrayFixture.of(primitiveType)
        def propertyType = "ListProperty<$fixture.arrayType>"
        def propertyValue = "listOf($fixture.arrayValue, $fixture.arrayValue)"

                return DecoderExtensions.readLengthPrefixedBooleans(decoder);
            }
        };

        public final Class<?> arrayType;

        PrimitiveType(Class<?> arrayType) {
            this.arrayType = arrayType;
        }

        public abstract Object clone(Object array);

        public abstract boolean equals(Object x, Object y);

        }

        @Override
        public Isolatable<?> emptyArray(Class<?> arrayType) {
            return IsolatedArray.empty(arrayType);
        }

        @Override
        public Isolatable<?> array(ImmutableList<Isolatable<?>> elements, Class<?> arrayType) {
            return new IsolatedArray(elements, arrayType);
        }

        @Override
        public Isolatable<?> primitiveArray(Object value) {

    override suspend fun WriteContext.encode(value: IsolatedArray) {
        writeClass(value.arrayType)
        write(value.elements)
    }

    override suspend fun ReadContext.decode(): IsolatedArray {
        val arrayType = readClass()
        val elements = readNonNull<ImmutableList<Isolatable<*>>>()
        return IsolatedArray(elements, arrayType)
    }
}


object StringValueSnapshotCodec : Codec<StringValueSnapshot> {

func (t *Type) MapType() *MapType {
	if t.Kind() != Map {
		return nil
	}
	return (*MapType)(unsafe.Pointer(t))
}

// ArrayType returns t cast to a *ArrayType, or nil if its tag does not match.
func (t *Type) ArrayType() *ArrayType {
	if t.Kind() != Array {
		return nil
	}
	return (*ArrayType)(unsafe.Pointer(t))
}

// FuncType returns t cast to a *FuncType, or nil if its tag does not match.

        }

        @Override
        public ValueSnapshot emptyArray(Class<?> arrayType) {
            return ArrayValueSnapshot.EMPTY;
        }

        @Override
        public ValueSnapshot array(ImmutableList<ValueSnapshot> elements, Class<?> arrayType) {
            return new ArrayValueSnapshot(elements);
        }

        @Override

	registerBasics()
	wireTypeUserInfo = userType(wireTypeType)
}

// Array type
type arrayType struct {
	CommonType
	Elem typeId
	Len  int
}

func newArrayType(name string) *arrayType {
	a := &arrayType{CommonType{Name: name}, 0, 0}
	return a
}

func (a *arrayType) init(elem gobType, len int) {
	// Set our type id before evaluating the element's, in case it's our own.
	setTypeId(a)

      runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/annotatedType.kt");
    }

    @Test
    @TestMetadata("arrayType.kt")
    public void testArrayType() {
      runTest("analysis/analysis-api/testData/annotations/annotationsOnDeclaration/direct/arrayType.kt");
    }

    @Test
    @TestMetadata("arrayType2.kt")
    public void testArrayType2() {