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

class C<T extends core::Object> extends core::Object {
  generic-covariant-impl generic-covariant-interface 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 dynamic #t2 = #t1.{self::C::t} = 1.0 in #t1;
  self::C<dynamic> c_dynamic = new self::C::•<dynamic>(42);
  x.{self::C::t} = let final dynamic #t3 = "hello" in let dynamic _ = 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';
                                                       ^";
}
static method main() → dynamic {}
