call-inferred.ts

functionfoo<T>(a: T): T{
returna;
}

assert(foo(42)==42);
assert(foo(42.0)==42);
assert(foo(<f32>42.0)==42);

functionbar<T>(a: T=<f32>42.0): T{
returna;
}

assert(bar()==42);

classFoo<T>{
constructor(publicvalue: T){}
staticcreate<T>(value: T): Foo<T>{
returnnewFoo(value);
}
}

assert(newFoo(42).value==42);
assert(Foo.create(42).value==42);

classBar{
doSomething<T>(a: T): T{
returna;
}
}

assert(newBar().doSomething(42)==42);

classBaz<T>extendsFoo<T>{}
assert(newBaz(42).value==42);

// TODO: this'd require return type inference, i.e., omitted return type
// function baz<T>(a: i32): T {
// return a;
// }
// baz(42);

// TODO: this'd ideally be inferred by matching contextualType, avoiding conversions
// function baz<T>(): T {
// return 1;
// }
// baz(42);