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

class C<T extends core::Object = dynamic> extends core::Object {
  generic-covariant-impl field self::C::T t;
  constructor •(self::C::T t) → void
    : self::C::t = t, super core::Object::•()
    ;
}
static method test() → dynamic {
  self::C<core::int> x = new self::C::•<core::int>(42);
  core::num y;
  self::C<core::int> c_int = new self::C::•<core::int>(y as{TypeError} core::int);
  self::C<core::num> c_num = new self::C::•<core::num>(123);
  self::C<core::num> c_num2 = let final self::C<core::num> #t1 = new self::C::•<core::num>(456) in let final core::double #t2 = #t1.{self::C::t} = 1.0 in #t1;
  self::C<dynamic> c_dynamic = new self::C::•<dynamic>(42);
  x.{self::C::t} = let<BottomType> _ = null in let final dynamic #t3 = let<BottomType> _ = null in invalid-expression "pkg/front_end/testcases/inference/constructors_infer_from_arguments.dart:26:56: Error: A value of type 'dart.core::String' can't be assigned to a variable of type 'dart.core::int'.
Try changing the type of the left hand side, or casting the right hand side to 'dart.core::int'.
  x. /*@target=C::t*/ t = /*error:INVALID_ASSIGNMENT*/ 'hello';
                                                       ^" in let final core::String #t4 = "hello" in null;
}
static method main() → dynamic {}
