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)

func (t *QualType) Size() int64 { return t.Type.Size() }

// An ArrayType represents a fixed size array type.
type ArrayType struct {
	CommonType
	Type          Type
	StrideBitSize int64 // if > 0, number of bits to hold each element
	Count         int64 // if == -1, an incomplete array, like char x[].
}

func (t *ArrayType) String() string {
	return "[" + strconv.FormatInt(t.Count, 10) + "]" + t.Type.String()

      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() {

		return nil, fmt.Errorf("expected call expression with 1 argument; got %d", len(call.Args))
	}
	arg := call.Args[0]

	if arrayType, ok := call.Fun.(*ast.ArrayType); ok {
		if arrayType.Len != nil {
			return nil, fmt.Errorf("expected []byte or primitive type")
		}
		elt, ok := arrayType.Elt.(*ast.Ident)
		if !ok || elt.Name != "byte" {
			return nil, fmt.Errorf("expected []byte")
		}
		lit, ok := arg.(*ast.BasicLit)

      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() {

      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() {

//         Elem typeOff
//     }
//
//     type SliceType struct {
//         Tag  itag // sliceType
//         Elem typeOff
//     }
//
//     type ArrayType struct {
//         Tag  itag // arrayType
//         Len  uint64
//         Elem typeOff
//     }
//
//     type ChanType struct {
//         Tag  itag   // chanType
//         Dir  uint64 // 1 RecvOnly; 2 SendOnly; 3 SendRecv

      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() {