Language Specification Question

Question

I am in the process of developing a Java language extension and have encountered a bizarre syntax question. Please consider the following code:
public class Example
    public static void main(String[] arg) throws Exception
        Bar<String> bar = new Bar<String>(new Foo<String>(){
            public String makeT() {
                return "hi";
class Bar<T> implements Foo<T>
    public Bar(Foo<T> maker) {
        this.maker = maker;
    Foo<T> maker;
    public T makeT()
        return maker.makeT();
    public void foo()
        class T {};
        T t = makeT();
interface Foo<T>
    T makeT();
}The point of this large and cumbersome example is to ensure that 1. I have a type and a type parameter which conflict, 2. the type parameter does not take prececdence, and 3. that I can instantiate an instance of the type parameter. My question is this: is there any syntax which would allow me, inside of the Bar.foo method, to create a reference of the type parameter[t] type rather than the local class type?
I know that this is a convoluted example, but it comes as a result of the metaprogramming environment my team is trying to develop. If there is no such syntax, this will not be a problem; we just need to know definitively one way or the other and consulting the community seemed to be a good heuristic before I dive into the language spec.

Answer 1

The point of this large and cumbersome example is to ensure that 1. I have a type and a type parameter which conflict, 2. the type parameter does not take prececdence, and 3. that I can instantiate an instance of the type parameter. My question is this: is there any syntax which would allow me, inside of the Bar.foo method, to create a reference of the type parameter type rather than the local class type?
Do you mean other than by calling makeT() or maker.makeT()? It's hard to see how, given that the values of type parameters are not accessible in run-time. In particular there is no way to call any constructor that the value of T might have.
If you change the definition of Bar to be basically a decorator for Class<T> then you can create instances of T using reflection:
class Baz<T> implements Foo<T> {
    Class<T> clazz;
    public Baz(Class<T> c) {
     clazz = c;
    public T makeT() {
     try {
         return clazz.newInstance();
     } catch (Exception e) {
         throw new RuntimeException(e);
}