/* * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.reflect.generics.visitor;  import java.lang.reflect.Type;import java.util.List;import java.util.Iterator;import sun.reflect.generics.tree.*;import sun.reflect.generics.factory.*;   /** * Visitor that converts AST to reified types. */public class Reifier implements TypeTreeVisitor<Type> {    private Type resultType;    private GenericsFactory factory;     private Reifier(GenericsFactory f){        factory = f;    }     private GenericsFactory getFactory(){ return factory;}     /**     * Factory method. The resulting visitor will convert an AST     * representing generic signatures into corresponding reflective     * objects, using the provided factory, <tt>f</tt>.     * @param f - a factory that can be used to manufacture reflective     * objects returned by this visitor     * @return A visitor that can be used to reify ASTs representing     * generic type information into reflective objects     */    public static Reifier make(GenericsFactory f){        return new Reifier(f);    }     // Helper method. Visits an array of TypeArgument and produces    // reified Type array.    private Type[] reifyTypeArguments(TypeArgument[] tas) {        Type[] ts = new Type[tas.length];        for (int i = 0; i < tas.length; i++) {            tas[i].accept(this);            ts[i] = resultType;        }        return ts;    }      /**     * Accessor for the result of the last visit by this visitor,     * @return The type computed by this visitor based on its last     * visit     */    public Type getResult() { assert resultType != null;return resultType;}     public void visitFormalTypeParameter(FormalTypeParameter ftp){        resultType = getFactory().makeTypeVariable(ftp.getName(),                                                   ftp.getBounds());    }      public void visitClassTypeSignature(ClassTypeSignature ct){        // This method examines the pathname stored in ct, which has the form        // n1.n2...nk<targs>....        // where n1 ... nk-1 might not exist OR        // nk might not exist (but not both). It may be that k equals 1.        // The idea is that nk is the simple class type name that has        // any type parameters associated with it.        //  We process this path in two phases.        //  First, we scan until we reach nk (if it exists).        //  If nk does not exist, this identifies a raw class n1 ... nk-1        // which we can return.        // if nk does exist, we begin the 2nd phase.        // Here nk defines a parameterized type. Every further step nj (j > k)        // down the path must also be represented as a parameterized type,        // whose owner is the representation of the previous step in the path,        // n{j-1}.         // extract iterator on list of simple class type sigs        List<SimpleClassTypeSignature> scts = ct.getPath();        assert(!scts.isEmpty());        Iterator<SimpleClassTypeSignature> iter = scts.iterator();        SimpleClassTypeSignature sc = iter.next();        StringBuilder n = new StringBuilder(sc.getName());        boolean dollar = sc.getDollar();         // phase 1: iterate over simple class types until        // we are either done or we hit one with non-empty type parameters        while (iter.hasNext() && sc.getTypeArguments().length == 0) {            sc = iter.next();            dollar = sc.getDollar();            n.append(dollar?"$":".").append(sc.getName());        }         // Now, either sc is the last element of the list, or        // it has type arguments (or both)        assert(!(iter.hasNext()) || (sc.getTypeArguments().length > 0));        // Create the raw type        Type c = getFactory().makeNamedType(n.toString());        // if there are no type arguments        if (sc.getTypeArguments().length == 0) {            //we have surely reached the end of the path            assert(!iter.hasNext());            resultType = c; // the result is the raw type        } else {            assert(sc.getTypeArguments().length > 0);            // otherwise, we have type arguments, so we create a parameterized            // type, whose declaration is the raw type c, and whose owner is            // the declaring class of c (if any). This latter fact is indicated            // by passing null as the owner.            // First, we reify the type arguments            Type[] pts = reifyTypeArguments(sc.getTypeArguments());             Type owner = getFactory().makeParameterizedType(c, pts, null);            // phase 2: iterate over remaining simple class types            dollar =false;            while (iter.hasNext()) {                sc = iter.next();                dollar = sc.getDollar();                n.append(dollar?"$":".").append(sc.getName()); // build up raw class name                c = getFactory().makeNamedType(n.toString()); // obtain raw class                pts = reifyTypeArguments(sc.getTypeArguments());// reify params                // Create a parameterized type, based on type args, raw type                // and previous owner                owner = getFactory().makeParameterizedType(c, pts, owner);            }            resultType = owner;        }    }     public void visitArrayTypeSignature(ArrayTypeSignature a){        // extract and reify component type        a.getComponentType().accept(this);        Type ct = resultType;        resultType = getFactory().makeArrayType(ct);    }     public void visitTypeVariableSignature(TypeVariableSignature tv){        resultType = getFactory().findTypeVariable(tv.getIdentifier());    }     public void visitWildcard(Wildcard w){        resultType = getFactory().makeWildcard(w.getUpperBounds(),                                               w.getLowerBounds());    }     public void visitSimpleClassTypeSignature(SimpleClassTypeSignature sct){        resultType = getFactory().makeNamedType(sct.getName());    }     public void visitBottomSignature(BottomSignature b){     }     public void visitByteSignature(ByteSignature b){        resultType = getFactory().makeByte();    }     public void visitBooleanSignature(BooleanSignature b){        resultType = getFactory().makeBool();    }     public void visitShortSignature(ShortSignature s){        resultType = getFactory().makeShort();    }     public void visitCharSignature(CharSignature c){        resultType = getFactory().makeChar();    }     public void visitIntSignature(IntSignature i){        resultType = getFactory().makeInt();    }     public void visitLongSignature(LongSignature l){        resultType = getFactory().makeLong();    }     public void visitFloatSignature(FloatSignature f){        resultType = getFactory().makeFloat();    }     public void visitDoubleSignature(DoubleSignature d){        resultType = getFactory().makeDouble();    }     public void visitVoidDescriptor(VoidDescriptor v){        resultType = getFactory().makeVoid();    }  }