// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
//
// Dart test program for testing dart:ffi extra checks
//
// SharedObjects=ffi_test_dynamic_library ffi_test_functions

// @dart = 2.9

import 'dart:ffi';

import "package:ffi/ffi.dart";

import 'dylib_utils.dart';

void main() {
  testGetGeneric();
  testGetGeneric2();
  testGetVoid();
  testGetNativeFunction();
  testGetNativeType();
  testGetTypeMismatch();
  testSetGeneric();
  testSetGeneric2();
  testSetVoid();
  testSetNativeFunction();
  testSetNativeType();
  testSetTypeMismatch();
  testAsFunctionGeneric();
  testAsFunctionGeneric2();
  testAsFunctionWrongNativeFunctionSignature();
  testAsFunctionTypeMismatch();
  testFromFunctionGeneric();
  testFromFunctionGeneric2();
  testFromFunctionWrongNativeFunctionSignature();
  testFromFunctionTypeMismatch();
  testFromFunctionClosure();
  testFromFunctionTearOff();
  testFromFunctionAbstract();
  testFromFunctionFunctionExceptionValueMustBeConst();
  testLookupFunctionGeneric();
  testLookupFunctionGeneric2();
  testLookupFunctionWrongNativeFunctionSignature();
  testLookupFunctionTypeMismatch();
  testLookupFunctionPointervoid();
  testLookupFunctionPointerNFdyn();
  testNativeFunctionSignatureInvalidReturn();
  testNativeFunctionSignatureInvalidParam();
  testNativeFunctionSignatureInvalidOptionalNamed();
  testNativeFunctionSignatureInvalidOptionalPositional();
  testHandleVariance();
  testEmptyStructLookupFunctionArgument();
  testEmptyStructLookupFunctionReturn();
  testEmptyStructAsFunctionArgument();
  testEmptyStructAsFunctionReturn();
  testEmptyStructFromFunctionArgument();
  testEmptyStructFromFunctionReturn();
  testAllocateGeneric();
  testAllocateNativeType();
  testRefStruct();
  testSizeOfGeneric();
  testSizeOfNativeType();
  testSizeOfHandle();
  testElementAtGeneric();
  testElementAtNativeType();
  testLookupFunctionIsLeafMustBeConst();
  testAsFunctionIsLeafMustBeConst();
  testLookupFunctionTakesHandle();
  testAsFunctionTakesHandle();
  testLookupFunctionReturnsHandle();
  testAsFunctionReturnsHandle();
}

typedef Int8UnOp = Int8 Function(Int8);
typedef IntUnOp = int Function(int);

void testGetGeneric() {
  int generic(Pointer p) {
    int result;
    result = p.value; //# 20: compile-time error
    return result;
  }

  Pointer<Int8> p = calloc();
  p.value = 123;
  Pointer loseType = p;
  generic(loseType);
  calloc.free(p);
}

void testGetGeneric2() {
  T generic<T extends Object>() {
    Pointer<Int8> p = calloc();
    p.value = 123;
    T result;
    result = p.value; //# 21: compile-time error
    calloc.free(p);
    return result;
  }

  generic<int>();
}

void testGetVoid() {
  Pointer<IntPtr> p1 = calloc();
  Pointer<Void> p2 = p1.cast();

  p2.value; //# 22: compile-time error

  calloc.free(p1);
}

void testGetNativeFunction() {
  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
  IntUnOp f = p.value; //# 23: compile-time error
}

void testGetNativeType() {
  // Is it possible to obtain a Pointer<NativeType> at all?
}

void testGetTypeMismatch() {
  Pointer<Pointer<Int16>> p = calloc();
  Pointer<Int16> typedNull = nullptr;
  p.value = typedNull;

  // this fails to compile due to type mismatch
  Pointer<Int8> p2 = p.value; //# 25: compile-time error

  calloc.free(p);
}

void testSetGeneric() {
  void generic(Pointer p) {
    p.value = 123; //# 26: compile-time error
  }

  Pointer<Int8> p = calloc();
  p.value = 123;
  Pointer loseType = p;
  generic(loseType);
  calloc.free(p);
}

void testSetGeneric2() {
  void generic<T extends Object>(T arg) {
    Pointer<Int8> p = calloc();
    p.value = arg; //# 27: compile-time error
    calloc.free(p);
  }

  generic<int>(123);
}

void testSetVoid() {
  Pointer<IntPtr> p1 = calloc();
  Pointer<Void> p2 = p1.cast();

  p2.value = 1234; //# 28: compile-time error

  calloc.free(p1);
}

void testSetNativeFunction() {
  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
  IntUnOp f = (a) => a + 1;
  p.value = f; //# 29: compile-time error
}

void testSetNativeType() {
  // Is it possible to obtain a Pointer<NativeType> at all?
}

void testSetTypeMismatch() {
  // the pointer to pointer types must match up
  Pointer<Int8> pHelper = calloc();
  pHelper.value = 123;

  Pointer<Pointer<Int16>> p = calloc();

  // this fails to compile due to type mismatch
  p.value = pHelper; //# 40: compile-time error

  calloc.free(pHelper);
  calloc.free(p);
}

void testAsFunctionGeneric() {
  T generic<T extends Function>() {
    Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
    Function f;
    f = p.asFunction<T>(); //# 11: compile-time error
    return f;
  }

  generic<IntUnOp>();
}

void testAsFunctionGeneric2() {
  generic(Pointer<NativeFunction> p) {
    Function f;
    f = p.asFunction<IntUnOp>(); //# 12: compile-time error
    return f;
  }

  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
  generic(p);
}

void testAsFunctionWrongNativeFunctionSignature() {
  Pointer<NativeFunction<IntUnOp>> p;
  Function f = p.asFunction<IntUnOp>(); //# 13: compile-time error
}

typedef IntBinOp = int Function(int, int);

void testAsFunctionTypeMismatch() {
  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
  IntBinOp f = p.asFunction(); //# 14: compile-time error
}

typedef NativeDoubleUnOp = Double Function(Double);
typedef DoubleUnOp = double Function(double);

double myTimesThree(double d) => d * 3;

int myTimesFour(int i) => i * 4;

void testFromFunctionGeneric() {
  Pointer<NativeFunction> generic<T extends Function>(T f) {
    Pointer<NativeFunction<NativeDoubleUnOp>> result;
    result = Pointer.fromFunction(f); //# 70: compile-time error
    return result;
  }

  generic(myTimesThree);
}

void testFromFunctionGeneric2() {
  Pointer<NativeFunction<T>> generic<T extends Function>() {
    Pointer<NativeFunction<T>> result;
    result = Pointer.fromFunction(myTimesThree); //# 71: compile-time error
    return result;
  }

  generic<NativeDoubleUnOp>();
}

void testFromFunctionWrongNativeFunctionSignature() {
  Pointer.fromFunction<IntUnOp>(myTimesFour); //# 72: compile-time error
}

void testFromFunctionTypeMismatch() {
  Pointer<NativeFunction<NativeDoubleUnOp>> p;
  p = Pointer.fromFunction(myTimesFour); //# 73: compile-time error
}

void testFromFunctionClosure() {
  DoubleUnOp someClosure = (double z) => z / 27.0;
  Pointer<NativeFunction<NativeDoubleUnOp>> p;
  p = Pointer.fromFunction(someClosure); //# 74: compile-time error
}

class X {
  double tearoff(double d) => d / 27.0;
}

void testFromFunctionTearOff() {
  DoubleUnOp fld = X().tearoff;
  Pointer<NativeFunction<NativeDoubleUnOp>> p;
  p = Pointer.fromFunction(fld); //# 75: compile-time error
}

void testFromFunctionAbstract() {
  Pointer.fromFunction<Function>(//# 76: compile-time error
      testFromFunctionAbstract); //# 76: compile-time error
}

void testFromFunctionFunctionExceptionValueMustBeConst() {
  final notAConst = 1.1;
  Pointer<NativeFunction<NativeDoubleUnOp>> p;
  p = Pointer.fromFunction(myTimesThree, notAConst); //# 77: compile-time error
}

void testLookupFunctionGeneric() {
  Function generic<T extends Function>() {
    DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
    Function result;
    result = l.lookupFunction<T, DoubleUnOp>("cos"); //# 15: compile-time error
    return result;
  }

  generic<NativeDoubleUnOp>();
}

void testLookupFunctionGeneric2() {
  Function generic<T extends Function>() {
    DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
    Function result;
    result = //# 16: compile-time error
        l.lookupFunction<NativeDoubleUnOp, T>("cos"); //# 16: compile-time error
    return result;
  }

  generic<DoubleUnOp>();
}

void testLookupFunctionWrongNativeFunctionSignature() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  l.lookupFunction<IntUnOp, IntUnOp>("cos"); //# 17: compile-time error
}

void testLookupFunctionTypeMismatch() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  l.lookupFunction<NativeDoubleUnOp, IntUnOp>("cos"); //# 18: compile-time error
}

typedef PointervoidN = Void Function(Pointer<void>);
typedef PointervoidD = void Function(Pointer<void>);

void testLookupFunctionPointervoid() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  // TODO(https://dartbug.com/44593): This should be a compile-time error in CFE.
  // l.lookupFunction<PointervoidN, PointervoidD>("cos");
}

typedef PointerNFdynN = Void Function(Pointer<NativeFunction>);
typedef PointerNFdynD = void Function(Pointer<NativeFunction>);

void testLookupFunctionPointerNFdyn() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  // TODO(https://dartbug.com/44594): Should this be an error or not?
  // l.lookupFunction<PointerNFdynN, PointerNFdynD>("cos");
}

// TODO(dacoharkes): make the next 4 test compile errors
typedef Invalid1 = int Function(Int8);
typedef Invalid2 = Int8 Function(int);
typedef Invalid3 = Int8 Function({Int8 named});
typedef Invalid4 = Int8 Function([Int8 positional]);

void testNativeFunctionSignatureInvalidReturn() {
  // Pointer<NativeFunction<Invalid1>> p = fromAddress(999);
}

void testNativeFunctionSignatureInvalidParam() {
  // Pointer<NativeFunction<Invalid2>> p = fromAddress(999);
}

void testNativeFunctionSignatureInvalidOptionalNamed() {
  // Pointer<NativeFunction<Invalid3>> p = fromAddress(999);
}

void testNativeFunctionSignatureInvalidOptionalPositional() {
  // Pointer<NativeFunction<Invalid4>> p = fromAddress(999);
}

// error on missing field annotation
class TestStruct extends Struct {
  @Double()
  double x;

  double y; //# 50: compile-time error
}

// Cannot extend structs.
class TestStruct3 extends TestStruct {} //# 52: compile-time error

// error on double annotation
class TestStruct4 extends Struct {
  @Double()
  @Double() //# 53: compile-time error
  double z;
}

// error on annotation not matching up
class TestStruct5 extends Struct {
  @Int64() //# 54: compile-time error
  double z; //# 54: compile-time error

  Pointer notEmpty;
}

// error on annotation not matching up
class TestStruct6 extends Struct {
  @Void() //# 55: compile-time error
  double z; //# 55: compile-time error

  Pointer notEmpty;
}

// error on annotation not matching up
class TestStruct7 extends Struct {
  @NativeType() //# 56: compile-time error
  double z; //# 56: compile-time error

  Pointer notEmpty;
}

// error on field initializer on field
class TestStruct8 extends Struct {
  @Double() //# 57: compile-time error
  double z = 10.0; //# 57: compile-time error

  Pointer notEmpty;
}

// error on field initializer in constructor
class TestStruct9 extends Struct {
  @Double()
  double z;

  TestStruct9() : z = 0.0 {} //# 58: compile-time error
}

// Struct classes may not be generic.
class TestStruct11<T> extends //# 60: compile-time error
    Struct<TestStruct11<dynamic>> {} //# 60: compile-time error

// Structs may not appear inside structs (currently, there is no suitable
// annotation).
class TestStruct12 extends Struct {
  @Pointer //# 61: compile-time error
  TestStruct9 struct; //# 61: compile-time error

  Pointer notEmpty;
}

class DummyAnnotation {
  const DummyAnnotation();
}

// Structs fields may have other annotations.
class TestStruct13 extends Struct {
  @DummyAnnotation()
  @Double()
  double z;
}

// Cannot extend native types.

class ENativeType extends NativeType {} //# 90: compile-time error

class EInt8 extends Int8 {} //# 91: compile-time error

class EInt16 extends Int16 {} //# 92: compile-time error

class EInt32 extends Int32 {} //# 93: compile-time error

class EInt64 extends Int64 {} //# 94: compile-time error

class EUint8 extends Uint8 {} //# 95: compile-time error

class EUint16 extends Uint16 {} //# 96: compile-time error

class EUint32 extends Uint32 {} //# 97: compile-time error

class EUint64 extends Uint64 {} //# 98: compile-time error

class EIntPtr extends IntPtr {} //# 99: compile-time error

class EFloat extends Float {} //# 910: compile-time error

class EDouble extends Double {} //# 911: compile-time error

class EVoid extends Void {} //# 912: compile-time error

class ENativeFunction extends NativeFunction {} //# 913: compile-time error

class EPointer extends Pointer {} //# 914: compile-time error

// Cannot implement native natives or Struct.

// Cannot extend native types.

class INativeType implements NativeType {} //# 80: compile-time error

class IInt8 implements Int8 {} //# 81: compile-time error

class IInt16 implements Int16 {} //# 82: compile-time error

class IInt32 implements Int32 {} //# 83: compile-time error

class IInt64 implements Int64 {} //# 84: compile-time error

class IUint8 implements Uint8 {} //# 85: compile-time error

class IUint16 implements Uint16 {} //# 86: compile-time error

class IUint32 implements Uint32 {} //# 87: compile-time error

class IUint64 implements Uint64 {} //# 88: compile-time error

class IIntPtr implements IntPtr {} //# 88: compile-time error

class IFloat implements Float {} //# 810: compile-time error

class IDouble implements Double {} //# 811: compile-time error

class IVoid implements Void {} //# 812: compile-time error

class INativeFunction //# 813: compile-time error
    implements //# 813: compile-time error
        NativeFunction {} //# 813: compile-time error

class IPointer implements Pointer {} //# 814: compile-time error

class IStruct implements Struct {} //# 815: compile-time error

class IOpaque implements Opaque {} //# 816: compile-time error

class MyClass {
  int x;
  MyClass(this.x);
}

final testLibrary = dlopenPlatformSpecific("ffi_test_functions");

void testHandleVariance() {
  // Taking a more specific argument is okay.
  testLibrary.lookupFunction<Handle Function(Handle), Object Function(MyClass)>(
      "PassObjectToC");

  // Requiring a more specific return type is not, this requires a cast from
  // the user.
  testLibrary.lookupFunction< //# 1000: compile-time error
      Handle Function(Handle), //# 1000: compile-time error
      MyClass Function(Object)>("PassObjectToC"); //# 1000: compile-time error
}

class TestStruct1001 extends Struct {
  Handle handle; //# 1001: compile-time error

  Pointer notEmpty;
}

class TestStruct1002 extends Struct {
  @Handle() //# 1002: compile-time error
  Object handle; //# 1002: compile-time error

  Pointer notEmpty;
}

class EmptyStruct extends Struct {} //# 1099: compile-time error

class EmptyStruct extends Struct {} //# 1100: compile-time error

void testEmptyStructLookupFunctionArgument() {
  testLibrary.lookupFunction< //# 1100: compile-time error
      Void Function(EmptyStruct), //# 1100: compile-time error
      void Function(EmptyStruct)>("DoesNotExist"); //# 1100: compile-time error
}

class EmptyStruct extends Struct {} //# 1101: compile-time error

void testEmptyStructLookupFunctionReturn() {
  testLibrary.lookupFunction< //# 1101: compile-time error
      EmptyStruct Function(), //# 1101: compile-time error
      EmptyStruct Function()>("DoesNotExist"); //# 1101: compile-time error
}

class EmptyStruct extends Struct {} //# 1102: compile-time error

void testEmptyStructAsFunctionArgument() {
  final Pointer< //# 1102: compile-time error
          NativeFunction< //# 1102: compile-time error
              Void Function(EmptyStruct)>> //# 1102: compile-time error
      pointer = Pointer.fromAddress(1234); //# 1102: compile-time error
  pointer.asFunction<void Function(EmptyStruct)>(); //# 1102: compile-time error
}

class EmptyStruct extends Struct {} //# 1103: compile-time error

void testEmptyStructAsFunctionReturn() {
  final Pointer< //# 1103: compile-time error
          NativeFunction<EmptyStruct Function()>> //# 1103: compile-time error
      pointer = Pointer.fromAddress(1234); //# 1103: compile-time error
  pointer.asFunction<EmptyStruct Function()>(); //# 1103: compile-time error
}

class EmptyStruct extends Struct {} //# 1104: compile-time error

void _consumeEmptyStruct(EmptyStruct e) => //# 1104: compile-time error
    print(e); //# 1104: compile-time error

void testEmptyStructFromFunctionArgument() {
  Pointer.fromFunction<Void Function(EmptyStruct)>(//# 1104: compile-time error
      _consumeEmptyStruct); //# 1104: compile-time error
}

class EmptyStruct extends Struct {} //# 1105: compile-time error

EmptyStruct _returnEmptyStruct() => EmptyStruct(); //# 1105: compile-time error

void testEmptyStructFromFunctionReturn() {
  Pointer.fromFunction<EmptyStruct Function()>(//# 1105: compile-time error
      _returnEmptyStruct); //# 1105: compile-time error
}

class EmptyStruct extends Struct {} //# 1106: compile-time error

class HasNestedEmptyStruct extends Struct {
  EmptyStruct nestedEmptyStruct; //# 1106: compile-time error

  Pointer notEmpty;
}

void testAllocateGeneric() {
  Pointer<T> generic<T extends NativeType>() {
    Pointer<T> pointer = nullptr;
    pointer = calloc(); //# 1320: compile-time error
    return pointer;
  }

  Pointer p = generic<Int64>();
}

void testAllocateNativeType() {
  calloc(); //# 1321: compile-time error
}

void testRefStruct() {
  final myStructPointer = calloc<TestStruct13>();
  Pointer<Struct> structPointer = myStructPointer;
  structPointer.ref; //# 1330: compile-time error
  calloc.free(myStructPointer);
}

T genericRef<T extends Struct>(Pointer<T> p) => //# 1200: compile-time error
    p.ref; //# 1200: compile-time error

T genericRef2<T extends Struct>(Pointer<T> p) => //# 1201: compile-time error
    p.cast<T>().ref; //# 1201: compile-time error

T genericRef3<T extends Struct>(Pointer<T> p) => //# 1202: compile-time error
    p[0]; //# 1202: compile-time error

T genericRef4<T extends Struct>(Array<T> p) => //# 1210: compile-time error
    p[0]; //# 1210: compile-time error

void testSizeOfGeneric() {
  int generic<T extends Pointer>() {
    int size = sizeOf<IntPtr>();
    size = sizeOf<T>(); //# 1300: compile-time error
    return size;
  }

  int size = generic<Pointer<Int64>>();
}

void testSizeOfNativeType() {
  sizeOf(); //# 1301: compile-time error
}

void testSizeOfHandle() {
  sizeOf<Handle>(); //# 1302: compile-time error
}

void testElementAtGeneric() {
  Pointer<T> generic<T extends NativeType>(Pointer<T> pointer) {
    Pointer<T> returnValue = pointer;
    returnValue = returnValue.elementAt(1); //# 1310: compile-time error
    return returnValue;
  }

  Pointer<Int8> p = calloc();
  p.elementAt(1);
  generic(p);
  calloc.free(p);
}

void testElementAtNativeType() {
  Pointer<Int8> p = calloc();
  p.elementAt(1);
  Pointer<NativeType> p2 = p;
  p2.elementAt(1); //# 1311: compile-time error
  calloc.free(p);
}

class TestStruct1400 extends Struct {
  @Array(8) //# 1400: compile-time error
  @Array(8)
  Array<Uint8> a0;
}

class TestStruct1401 extends Struct {
  Array<Uint8> a0; //# 1401: compile-time error

  Pointer<Uint8> notEmpty;
}

class TestStruct1402 extends Struct {
  @Array(8, 8, 8) //# 1402: compile-time error
  Array<Array<Uint8>> a0; //# 1402: compile-time error

  Pointer<Uint8> notEmpty;
}

class TestStruct1403 extends Struct {
  @Array(8, 8) //# 1403: compile-time error
  Array<Array<Array<Uint8>>> a0; //# 1403: compile-time error

  Pointer<Uint8> notEmpty;
}

class TestStruct1404 extends Struct {
  @Array.multi([8, 8, 8]) //# 1404: compile-time error
  Array<Array<Uint8>> a0; //# 1404: compile-time error

  Pointer<Uint8> notEmpty;
}

class TestStruct1405 extends Struct {
  @Array.multi([8, 8]) //# 1405: compile-time error
  Array<Array<Array<Uint8>>> a0; //# 1405: compile-time error

  Pointer<Uint8> notEmpty;
}

void testLookupFunctionIsLeafMustBeConst() {
  bool notAConst = false;
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  l.lookupFunction< //# 1500: compile-time error
          NativeDoubleUnOp, //# 1500: compile-time error
          DoubleUnOp>("timesFour", //# 1500: compile-time error
      isLeaf: notAConst); //# 1500: compile-time error
}

void testAsFunctionIsLeafMustBeConst() {
  bool notAConst = false;
  Pointer<NativeFunction<Int8UnOp>> p = Pointer.fromAddress(1337);
  IntUnOp f = p.asFunction(isLeaf: notAConst); //# 1501: compile-time error
}

typedef NativeTakesHandle = Void Function(Handle);
typedef TakesHandle = void Function(Object);

void testLookupFunctionTakesHandle() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  l.lookupFunction< //# 1502: compile-time error
          NativeTakesHandle, //# 1502: compile-time error
          TakesHandle>("takesHandle", //# 1502: compile-time error
      isLeaf: true); //# 1502: compile-time error
}

void testAsFunctionTakesHandle() {
  Pointer<NativeFunction<NativeTakesHandle>> p = //# 1503: compile-time error
      Pointer.fromAddress(1337); //# 1503: compile-time error
  TakesHandle f = p.asFunction(isLeaf: true); //# 1503: compile-time error
}

typedef NativeReturnsHandle = Handle Function();
typedef ReturnsHandle = Object Function();

void testLookupFunctionReturnsHandle() {
  DynamicLibrary l = dlopenPlatformSpecific("ffi_test_dynamic_library");
  l.lookupFunction< //# 1504: compile-time error
          NativeReturnsHandle, //# 1504: compile-time error
          ReturnsHandle>("returnsHandle", //# 1504: compile-time error
      isLeaf: true); //# 1504: compile-time error
}

void testAsFunctionReturnsHandle() {
  Pointer<NativeFunction<NativeReturnsHandle>> p = //# 1505: compile-time error
      Pointer.fromAddress(1337); //# 1505: compile-time error
  ReturnsHandle f = p.asFunction(isLeaf: true); //# 1505: compile-time error
}

@Packed(1)
class TestStruct1600 extends Struct {
  Pointer<Uint8> notEmpty;
}

@Packed(1)
@Packed(1) //# 1601: compile-time error
class TestStruct1601 extends Struct {
  Pointer<Uint8> notEmpty;
}

@Packed(3) //# 1602: compile-time error
class TestStruct1602 extends Struct {
  Pointer<Uint8> notEmpty;
}

class TestStruct1603 extends Struct {
  Pointer<Uint8> notEmpty;
}

@Packed(1)
class TestStruct1603Packed extends Struct {
  Pointer<Uint8> notEmpty;

  TestStruct1603 nestedNotPacked; //# 1603: compile-time error
}

@Packed(8)
class TestStruct1604 extends Struct {
  Pointer<Uint8> notEmpty;
}

@Packed(1)
class TestStruct1604Packed extends Struct {
  Pointer<Uint8> notEmpty;

  TestStruct1604 nestedLooselyPacked; //# 1604: compile-time error
}

@Packed(1)
class TestStruct1605Packed extends Struct {
  Pointer<Uint8> notEmpty;

  @Array(2) //# 1605: compile-time error
  Array<TestStruct1603> nestedNotPacked; //# 1605: compile-time error
}

@Packed(1)
class TestStruct1606Packed extends Struct {
  Pointer<Uint8> notEmpty;

  @Array(2) //# 1606: compile-time error
  Array<TestStruct1604> nestedLooselyPacked; //# 1606: compile-time error
}

@Packed(0) //# 1607: compile-time error
class TestStruct1607 extends Struct {
  Pointer<Uint8> notEmpty;
}

class TestStruct1800 extends Struct {
  Pointer<Uint8> notEmpty;

  @Array(-1) //# 1800: compile-time error
  Array<Uint8> inlineArray; //# 1800: compile-time error
}

class TestStruct1801 extends Struct {
  Pointer<Uint8> notEmpty;

  @Array(1, -1) //# 1801: compile-time error
  Array<Uint8> inlineArray; //# 1801: compile-time error
}

class TestStruct1802 extends Struct {
  Pointer<Uint8> notEmpty;

  @Array.multi([2, 2, 2, 2, 2, 2, -1]) //# 1802: compile-time error
  Array<Uint8> inlineArray; //# 1802: compile-time error
}

@AbiSpecificIntegerMapping({
  Abi.androidArm: Uint32(),
  Abi.androidArm64: IntPtr(), //# 1900: compile-time error
  Abi.androidIA32: AbiSpecificInteger1(), //# 1901: compile-time error
})
@AbiSpecificIntegerMapping({}) //# 1902: compile-time error
class AbiSpecificInteger1 extends AbiSpecificInteger {
  const AbiSpecificInteger1();

  int get a => 4; //# 1910: compile-time error

  int b; //# 1911: compile-time error
}

class AbiSpecificInteger2
    implements AbiSpecificInteger //# 1903: compile-time error
{
  const AbiSpecificInteger2();
}

class AbiSpecificInteger3
    extends AbiSpecificInteger1 //# 1904: compile-time error
{
  const AbiSpecificInteger3();
}

class AbiSpecificInteger4
    implements AbiSpecificInteger1 //# 1905: compile-time error
{
  const AbiSpecificInteger4();
}

class MyFinalizableStruct extends Struct
    implements Finalizable //# 2000: compile-time error
{
   Pointer<Void> field;
}