import "various_lib.dart" deferred as lib;

ConstClassWithF constClassWithF1 = const ConstClassWithF(procedure);

class A {
  A operator -() => this;
  const A();
}

class B implements A {
  B operator -() => this;
  const B();
}

class C implements A {
  C operator -() => this;
  const C();
}

class Class<T extends A> {
  const Class(T t);
  const Class.method(T t) : this(-t);
  const Class.redirect(dynamic t) : this(t);
}

class ConstClassWithF {
  const ConstClassWithF(this.foo);
  final F foo;
}

class Foo<E> {
  const Foo(this.value,
      {this.saved2: const bool.fromEnvironment("foo", defaultValue: barFromEnv),
      bool x: const bool.fromEnvironment("foo", defaultValue: barFromEnv)})
      : saved = x;
  const bool initialized =
      const bool.fromEnvironment("foo", defaultValue: barFromEnv);
  final E value;
  final bool saved;
  final bool saved2;
}

class Subclass<T extends A> extends Class<T> {
  const Subclass(dynamic t) : super(t);
}

const ConstClassWithF constClassWithF2 = const ConstClassWithF(procedure);
const Symbol symbolWithInvalidName = const Symbol("42");
const Symbol symbolWithUnevaluatedParameter =
    const Symbol(String.fromEnvironment("foo"));
const bool? barFromEnvOrNull0 = const bool.fromEnvironment("bar") ? true : null;
const bool? unevaluatedBoolOrNull =
    bool.fromEnvironment("bar") ? unevaluatedBool : null;
const bool? y = true;
const bool andOnNull = barFromEnvOrNull && true;
const bool andOnNull2 = true && barFromEnvOrNull;
const bool barFromEnv = const bool.fromEnvironment("bar");
const bool barFromEnvOrNull =
    const bool.fromEnvironment("bar", defaultValue: barFromEnvOrNull0!);
const bool conditionalOnNull = barFromEnvOrNull ? true : false;
const bool hasBarEnv = const bool.hasEnvironment("bar");
const bool isItInt = maybeInt is int ? true : false;
const bool isItInt2 = maybeInt2 is int ? true : false;
const bool isItInt3 = maybeInt3 is int ? true : false;
const bool isList = listOfInt is List;
const bool isListOfInt = listOfInt is List<int>;
const bool isListOfListOfInt = listOfListOfInt is List<List<int>>;
const bool isListOfNull = listOfNull is List<Null>;
const bool isMapOfInt = mapOfInt is Map<int, int>;
const bool isMapOfMapOfInt1 = mapOfMapOfInt1 is Map<Map<int, int>, int>;
const bool isMapOfMapOfInt2 = mapOfMapOfInt2 is Map<int, Map<int, int>>;
const bool isSetOfInt = setOfInt is Set<int>;
const bool isSetOfSetOfInt = setOfSetOfInt is Set<Set<int>>;
const bool notBarFromEnvOrNull = !barFromEnvOrNull;
const bool notUnevaluatedBool = !unevaluatedBool;
const bool nullAwareOnNull = barFromEnvOrNull ?? true;
const bool orOnNull = barFromEnvOrNull || true;
const bool orOnNull2 = barFromEnvOrNull || false;
const bool orOnNull3 = true || barFromEnvOrNull;
const bool orOnNull4 = false || barFromEnvOrNull;
const bool unevaluatedBool = bool.fromEnvironment("foo");
const bool unevaluatedBoolNotNull = unevaluatedBoolOrNull!;
const bool z = !(y!);
const c0 = bool.fromEnvironment("x") ? null : const Class<B>.redirect(C());
const c1 = bool.fromEnvironment("x") ? null : const Class<A>.method(A());
const c2 = bool.fromEnvironment("x") ? null : const Subclass<B>(C());
const c3 = bool.fromEnvironment("x") ? null : const Class<A>(A());
const c4 = bool.fromEnvironment("x") ? null : const Class<B>.redirect(B());
const c5 = bool.fromEnvironment("x") ? null : const Subclass<A>(A());
const c6 = bool.fromEnvironment("x") ? null : const Subclass<B>(B());
const dynamic listOfInt = [42];
const dynamic listOfListOfInt = [
  [42]
];
const dynamic listOfNull = [null];
const dynamic mapOfInt = {42: 42};
const dynamic mapOfMapOfInt1 = {
  {42: 42}: 42
};
const dynamic mapOfMapOfInt2 = {
  42: {42: 42}
};
const dynamic setOfInt = {42};
const dynamic setOfSetOfInt = {
  {42}
};
const f = F;
const fromDeferredLib = lib.x;
const maybeInt = bool.fromEnvironment("foo") ? 42 : true;
const maybeInt2 = z ? 42 : true;
const maybeInt3 = z ? 42 : null;
const x = const Foo<int>(42);
int procedure(int i, {int named}) => i;
main() {}
typedef F = int Function(int, {int named});