One of the language changes in Project Coin is allowing inference on constructor call through the <> notation (aka 'diamond'); this bug tracks that work.

SUMMARY OF THE PROPOSAL

This proposal addresses the addition of limited type inference for
class instance creation expressions to the Java programming language.
In cases where parametrized types need to be explicitly declared for a
constructor, and the full parametrized type < T1 , T2 , ...Tn > of
that constructor is obvious from the context, then the  parameterized
type of the constructor can be replaced with an empty set of type
parameters: <>. The <>  construct is legal to use when constructing an
ob ject and either assigning it to a variable, or when passing  it as
a parameter.

For example, consider the following assignment statement:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

This is rather lengthy, so it can be replaced with this:

Map<String, List<String>> anagrams = new HashMap<>();
Posted Date : 2009-05-13 15:38:59.0

N/A

This feature will significantly reduce the code that the user should type for initializing generic classes.

Let's analyze what is the expected behavior of a prototype supporting this feature. Given the following (generic) class declaration:

class Foo<X> {
...
Foo(X x) {...}
...
}

the '<>' notation should allow to initialize a generic class without explicitly providing an instantiation for Foo's type parameters (X in this case). Instead, the type parameters are inferred from the surrounding assignment context (if available).

e.g.

Foo<String> foo = new Foo<>(); //inferred as Foo<String>

A possible Java-model for implementing '<>' is to translate the constructor call into a call to a static synthetic factory method that the compiler adds to Foo.

class Foo<X> {
...
Foo(X x) {...}
static <Z> Foo<Z> create$(Z z) {}
...
}

Foo<String> foo = new Foo<>(); --> Foo<String> = Foo.create$();

Note: the purpose of the above translation is to give an idea about the semantics of the diamond operator and not about the actual implementation. An actual implementation should take into account aspects as:

* Generic constructors that declare their own type variables
* accessibility modifiers
* var-args
* boxing/unboxing conversion
Posted Date : 2009-09-23 10:06:00.0

Foo<String> = new Foo<>(); --> Foo<String> = Foo.create$();

? doesnt this have to be

Foo<String> foo = new Foo<>(); --> Foo<String> foo = Foo.create$();