// Errors:
//
// pkg/front_end/testcases/type_variable_uses.dart:8:11: Error: Type variables can't be used in static members.
//     print(T);
//           ^
//
// pkg/front_end/testcases/type_variable_uses.dart:12:13: Error: Not a constant expression.
//     const C<T>();
//             ^
//
// pkg/front_end/testcases/type_variable_uses.dart:12:13: Error: Type variables can't be used in static members.
//     const C<T>();
//             ^
//
// pkg/front_end/testcases/type_variable_uses.dart:13:12: Error: Not a constant expression.
//     const <T>[];
//            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:13:12: Error: Type variables can't be used in static members.
//     const <T>[];
//            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:14:14: Error: Not a constant expression.
//     const <C<T>>[];
//              ^
//
// pkg/front_end/testcases/type_variable_uses.dart:14:14: Error: Type variables can't be used in static members.
//     const <C<T>>[];
//              ^
//
// pkg/front_end/testcases/type_variable_uses.dart:15:20: Error: Not a constant expression.
//     const <Object>[T];
//                    ^
//
// pkg/front_end/testcases/type_variable_uses.dart:15:20: Error: Type variables can't be used in static members.
//     const <Object>[T];
//                    ^
//
// pkg/front_end/testcases/type_variable_uses.dart:16:28: Error: Not a constant expression.
//     const <Object>[const C<T>()];
//                            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:16:28: Error: Type variables can't be used in static members.
//     const <Object>[const C<T>()];
//                            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:24:13: Error: Not a constant expression.
//     const C<T>();
//             ^
//
// pkg/front_end/testcases/type_variable_uses.dart:24:13: Error: Type variables can't be used as constants.
//     const C<T>();
//             ^
//
// pkg/front_end/testcases/type_variable_uses.dart:25:12: Error: Not a constant expression.
//     const <T>[];
//            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:25:12: Error: Type variables can't be used as constants.
//     const <T>[];
//            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:26:14: Error: Not a constant expression.
//     const <C<T>>[];
//              ^
//
// pkg/front_end/testcases/type_variable_uses.dart:26:14: Error: Type variables can't be used as constants.
//     const <C<T>>[];
//              ^
//
// pkg/front_end/testcases/type_variable_uses.dart:27:20: Error: Not a constant expression.
//     const <Object>[T];
//                    ^
//
// pkg/front_end/testcases/type_variable_uses.dart:27:20: Error: Type variables can't be used as constants.
//     const <Object>[T];
//                    ^
//
// pkg/front_end/testcases/type_variable_uses.dart:28:28: Error: Not a constant expression.
//     const <Object>[const C<T>()];
//                            ^
//
// pkg/front_end/testcases/type_variable_uses.dart:28:28: Error: Type variables can't be used as constants.
//     const <Object>[const C<T>()];
//                            ^

library;
import self as self;
import "dart:core" as core;

class C<T extends core::Object = dynamic> extends core::Object {
  const constructor •() → void
    : super core::Object::•()
    ;
  static method staticMethod() → self::C<dynamic> {
    core::print(invalid-type);
    invalid-type t;
    self::C<invalid-type> l;
    self::C<self::C<invalid-type>> ll;
    const self::C::•<invalid-type>();
    const <invalid-type>[];
    const <self::C<invalid-type>>[];
    const <core::Object>[invalid-type];
    const <core::Object>[const self::C::•<invalid-type>()];
  }
  method instanceMethod() → self::C<self::C::T> {
    core::print(self::C::T);
    self::C::T t;
    self::C<self::C::T> l;
    self::C<self::C<self::C::T>> ll;
    const self::C::•<self::C::T>();
    const <self::C::T>[];
    const <self::C<self::C::T>>[];
    const <core::Object>[self::C::T];
    const <core::Object>[const self::C::•<self::C::T>()];
  }
}
static method main() → dynamic {}
