2.4/dev/core/src/com/google/gwt/dev/javac/asm/ResolveTypeSignature.java - gwt - Git at Google

 /*
  * Copyright 2009 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.dev.javac.asm;

 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
 import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.core.ext.typeinfo.JWildcardType.BoundType;
 import com.google.gwt.core.ext.typeinfo.NotFoundException;
 import com.google.gwt.dev.asm.signature.SignatureVisitor;
 import com.google.gwt.dev.javac.Resolver;
 import com.google.gwt.dev.javac.TypeParameterLookup;
 import com.google.gwt.dev.javac.typemodel.JClassType;
 import com.google.gwt.dev.javac.typemodel.JGenericType;
 import com.google.gwt.dev.javac.typemodel.JParameterizedType;
 import com.google.gwt.dev.javac.typemodel.JRealClassType;
 import com.google.gwt.dev.javac.typemodel.JTypeParameter;
 import com.google.gwt.dev.javac.typemodel.JWildcardType;
 import com.google.gwt.dev.util.Name;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 /**
  * Resolve a single parameterized type.
  */
 public class ResolveTypeSignature extends EmptySignatureVisitor {

   private final Resolver resolver;
   private final Map<String, JRealClassType> binaryMapper;
   private final TreeLogger logger;
   private final JType[] returnTypeRef;
   private final TypeParameterLookup lookup;
   private final char wildcardMatch;
   private final JClassType enclosingClass;

   private JClassType outerClass;
   private final List<JType[]> args = new ArrayList<JType[]>();
   private int arrayDepth = 0;

   /**
    * Resolve a parameterized type.
    *
    * @param resolver
    * @param binaryMapper
    * @param logger
    * @param returnTypeRef "pointer" to return location, ie. 1-element array
    * @param lookup
    * @param enclosingClass
    */
   public ResolveTypeSignature(Resolver resolver,
       Map<String, JRealClassType> binaryMapper, TreeLogger logger,
       JType[] returnTypeRef, TypeParameterLookup lookup,
       JClassType enclosingClass) {
     this(resolver, binaryMapper, logger, returnTypeRef, lookup, enclosingClass,
         '=');
   }

   public ResolveTypeSignature(Resolver resovler,
       Map<String, JRealClassType> binaryMapper, TreeLogger logger,
       JType[] returnTypeRef, TypeParameterLookup lookup,
       JClassType enclosingClass, char wildcardMatch) {
     this.resolver = resovler;
     this.binaryMapper = binaryMapper;
     this.logger = logger;
     this.returnTypeRef = returnTypeRef;
     this.lookup = lookup;
     this.enclosingClass = enclosingClass;
     this.wildcardMatch = wildcardMatch;
   }

   @Override
   public SignatureVisitor visitArrayType() {
     ++arrayDepth;
     return this;
   }

   @Override
   public void visitBaseType(char descriptor) {
     switch (descriptor) {
       case 'V':
         returnTypeRef[0] = JPrimitiveType.VOID;
         break;
       case 'B':
         returnTypeRef[0] = JPrimitiveType.BYTE;
         break;
       case 'J':
         returnTypeRef[0] = JPrimitiveType.LONG;
         break;
       case 'Z':
         returnTypeRef[0] = JPrimitiveType.BOOLEAN;
         break;
       case 'I':
         returnTypeRef[0] = JPrimitiveType.INT;
         break;
       case 'S':
         returnTypeRef[0] = JPrimitiveType.SHORT;
         break;
       case 'C':
         returnTypeRef[0] = JPrimitiveType.CHAR;
         break;
       case 'F':
         returnTypeRef[0] = JPrimitiveType.FLOAT;
         break;
       case 'D':
         returnTypeRef[0] = JPrimitiveType.DOUBLE;
         break;
       default:
         throw new IllegalStateException("Unrecognized base type " + descriptor);
     }
     // this is the last visitor called on this visitor
     visitEnd();
   }

   @Override
   public void visitClassType(String internalName) {
     assert Name.isInternalName(internalName);
     outerClass = enclosingClass;
     JRealClassType classType = binaryMapper.get(internalName);
     // TODO(jat): failures here are likely binary-only annotations or local
     // classes that have been elided from TypeOracle -- what should we do in
     // those cases? Currently we log an error and replace them with Object,
     // but we may can do something better.
     boolean resolveSuccess = classType == null ? false : resolver.resolveClass(
         logger, classType);
     returnTypeRef[0] = classType;
     if (!resolveSuccess || returnTypeRef[0] == null) {
       logger.log(TreeLogger.ERROR, "Unable to resolve class " + internalName);
       // Replace bound with Object if we can't resolve the class.
       returnTypeRef[0] = resolver.getTypeOracle().getJavaLangObject();
     }
   }

   @Override
   public void visitEnd() {
     if (returnTypeRef[0] == null) {
       return;
     }
     resolveGenerics();
   }

   @Override
   public void visitInnerClassType(String innerName) {
     // Called after visitClass has already been called, and we will
     // successively refine the class by going into its inner classes.
     assert returnTypeRef[0] != null;
     resolveGenerics();
     outerClass = (JClassType) returnTypeRef[0];
     JClassType searchClass = outerClass;
     try {
       JParameterizedType pt = searchClass.isParameterized();
       if (pt != null) {
         searchClass = pt.getBaseType();
       }
       returnTypeRef[0] = searchClass.getNestedType(innerName);
     } catch (NotFoundException e) {
       logger.log(TreeLogger.ERROR, "Unable to resolve inner class " + innerName
           + " in " + searchClass, e);
     }
   }

   @Override
   public void visitTypeArgument() {
     JType[] arg = new JType[1]; // This could be int[] for example
     arg[0] = resolver.getTypeOracle().getWildcardType(
         JWildcardType.BoundType.UNBOUND,
         resolver.getTypeOracle().getJavaLangObject());
     args.add(arg);
   }

   @Override
   public SignatureVisitor visitTypeArgument(char wildcard) {
     JType[] arg = new JType[1];
     args.add(arg);
     // TODO(jat): should we pass enclosingClass here instead of null?
     // not sure what the enclosing class of a type argument means, but
     // I haven't found a case where it is actually used while processing
     // the type argument.
     return new ResolveTypeSignature(resolver, binaryMapper, logger, arg,
         lookup, null, wildcard);
   }

   @Override
   public void visitTypeVariable(String name) {
     returnTypeRef[0] = lookup.lookup(name);
     // this is the last visitor called on this visitor
     visitEnd();
   }

   /**
    * Merge the bounds from the declared type parameters into the type arguments
    * for this type if necessary.
    *
    * <pre>
    * Example:
    * class Foo<T extends Bar> ...
    *
    * Foo<?> foo
    *
    * foo needs to have bounds ? extends Bar.
    * </pre>
    *
    * <p>
    * Currently we only deal with unbound wildcards as above, which matches
    * existing TypeOracleMediator behavior. However, this may need to be
    * extended.
    *
    * @param typeParams
    * @param typeArgs
    */
   private void mergeTypeParamBounds(JTypeParameter[] typeParams,
       JClassType[] typeArgs) {
     int n = typeArgs.length;
     for (int i = 0; i < n; ++i) {
       JWildcardType wildcard = typeArgs[i].isWildcard();
       // right now we only replace Foo<?> with the constraints defined on the
       // definition (which appears to match the existing TypeOracleMediator)
       // but other cases may need to be handled.
       if (wildcard != null
           && wildcard.getBoundType() == BoundType.UNBOUND
           && wildcard.getBaseType() == resolver.getTypeOracle().getJavaLangObject()
           && typeParams[i].getBaseType() != null) {
         typeArgs[i] = resolver.getTypeOracle().getWildcardType(
             BoundType.UNBOUND, typeParams[i].getBaseType());
       }
     }
   }

   private JType resolveGeneric(JType type, JClassType outer,
       JClassType[] typeArgs) {
     JGenericType genericType = (JGenericType) type.isGenericType();
     if (genericType != null) {
       int actual = typeArgs.length;
       JTypeParameter[] typeParams = genericType.getTypeParameters();
       int expected = typeParams.length;
       if (actual == 0 && expected > 0) {
         // If no type parameters were supplied, this is a raw type usage.
         type = genericType.getRawType();
       } else {
         if (actual != expected) {
           throw new IllegalStateException("Incorrect # of type parameters to "
               + genericType.getQualifiedBinaryName() + ": expected " + expected
               + ", actual=" + actual);
         }
         JClassType genericEnc = genericType.getEnclosingType();
         if (outer == null && genericEnc != null) {
           // Sometimes the signature is like Foo$Bar<H> even if Foo is a
           // generic class. The cases I have seen are where Foo's type
           // parameter is also named H and has the same bounds. That
           // manifests itself as getting visitClassType("Foo$Bar") and
           // then VisitTypeArgument/etc, rather than the usual
           // visitClassType("Foo"), visitTypeArgument/etc,
           // visitInnerClass("Bar"), visitTypeArgument/etc.
           //
           // So, in this case we have to build our own chain of enclosing
           // classes here, properly parameterizing any generics along the
           // way.
           // TODO(jat): more testing to validate this assumption
           JClassType[] outerArgs = null;
           JGenericType genericEncGeneric = genericEnc.isGenericType();
           if (genericEncGeneric != null) {
             JTypeParameter[] encTypeParams = genericEncGeneric.getTypeParameters();
             int n = encTypeParams.length;
             outerArgs = new JClassType[n];
             for (int i = 0; i < n; ++i) {
               outerArgs[i] = lookup.lookup(encTypeParams[i].getName());
               if (outerArgs[i] == null) {
                 // check to see if our current type has a parameter of the same
                 // name, and use it if so.
                 for (int j = 0; j < expected; ++j) {
                   if (typeParams[j].getName().equals(encTypeParams[j].getName())) {
                     outerArgs[i] = typeArgs[j];
                     break;
                   }
                 }
               }
               assert outerArgs[i] != null : "Unable to resolve type parameter "
                   + encTypeParams[i].getName() + " in enclosing type "
                   + genericEnc + " of type " + genericType;
             }
           }
           outer = (JClassType) resolveGeneric(genericEnc, null, outerArgs);
         }
         try {
           mergeTypeParamBounds(typeParams, typeArgs);
           type = resolver.getTypeOracle().getParameterizedType(genericType,
               outer, typeArgs);
         } catch (IllegalArgumentException e) {
           // Can't use toString on typeArgs as they aren't completely built
           // yet, so we have to roll our own.
           StringBuilder buf = new StringBuilder();
           buf.append("Unable to build parameterized type ");
           buf.append(genericType);
           String prefix = " with args <";
           for (JClassType typeArg : typeArgs) {
             buf.append(prefix).append(typeArg.getName());
             prefix = ", ";
           }
           if (", ".equals(prefix)) {
             buf.append('>');
           }
           logger.log(TreeLogger.ERROR, buf.toString(), e);
           type = genericType.getRawType();
         }
       }
     }
     return type;
   }

   private void resolveGenerics() {
     JGenericType genericType = (JGenericType) returnTypeRef[0].isGenericType();
     if (genericType != null) {
       int actual = args.size();
       JClassType[] typeArgs = new JClassType[actual];
       for (int i = 0; i < actual; ++i) {
         JType type = args.get(i)[0];
         if (!(type instanceof JClassType)) {
           logger.log(TreeLogger.ERROR, "Parameterized type argument is " + type
               + ", expected reference type");
         } else {
           typeArgs[i] = (JClassType) type;
         }
       }
       returnTypeRef[0] = resolveGeneric(genericType, outerClass, typeArgs);
       args.clear();
     }
     for (int i = 0; i < arrayDepth; ++i) {
       returnTypeRef[0] = resolver.getTypeOracle().getArrayType(returnTypeRef[0]);
     }
     switch (wildcardMatch) {
       case '=':
         // nothing to do for an exact match
         break;
       case '*':
         returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
             JWildcardType.BoundType.UNBOUND, (JClassType) returnTypeRef[0]);
         break;
       case '+':
         // ? extends T
         returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
             JWildcardType.BoundType.EXTENDS, (JClassType) returnTypeRef[0]);
         break;
       case '-':
         // ? super T
         returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
             JWildcardType.BoundType.SUPER, (JClassType) returnTypeRef[0]);
         break;
     }
     if (returnTypeRef[0] instanceof JClassType) {
       // Only JClassTypes can be an outer class
       outerClass = (JClassType) returnTypeRef[0];
     }
   }
 }
	/*
	* Copyright 2009 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.dev.javac.asm;

	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
	import com.google.gwt.core.ext.typeinfo.JType;
	import com.google.gwt.core.ext.typeinfo.JWildcardType.BoundType;
	import com.google.gwt.core.ext.typeinfo.NotFoundException;
	import com.google.gwt.dev.asm.signature.SignatureVisitor;
	import com.google.gwt.dev.javac.Resolver;
	import com.google.gwt.dev.javac.TypeParameterLookup;
	import com.google.gwt.dev.javac.typemodel.JClassType;
	import com.google.gwt.dev.javac.typemodel.JGenericType;
	import com.google.gwt.dev.javac.typemodel.JParameterizedType;
	import com.google.gwt.dev.javac.typemodel.JRealClassType;
	import com.google.gwt.dev.javac.typemodel.JTypeParameter;
	import com.google.gwt.dev.javac.typemodel.JWildcardType;
	import com.google.gwt.dev.util.Name;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;

	/**
	* Resolve a single parameterized type.
	*/
	public class ResolveTypeSignature extends EmptySignatureVisitor {

	private final Resolver resolver;
	private final Map<String, JRealClassType> binaryMapper;
	private final TreeLogger logger;
	private final JType[] returnTypeRef;
	private final TypeParameterLookup lookup;
	private final char wildcardMatch;
	private final JClassType enclosingClass;

	private JClassType outerClass;
	private final List<JType[]> args = new ArrayList<JType[]>();
	private int arrayDepth = 0;

	/**
	* Resolve a parameterized type.
	*
	* @param resolver
	* @param binaryMapper
	* @param logger
	* @param returnTypeRef "pointer" to return location, ie. 1-element array
	* @param lookup
	* @param enclosingClass
	*/
	public ResolveTypeSignature(Resolver resolver,
	Map<String, JRealClassType> binaryMapper, TreeLogger logger,
	JType[] returnTypeRef, TypeParameterLookup lookup,
	JClassType enclosingClass) {
	this(resolver, binaryMapper, logger, returnTypeRef, lookup, enclosingClass,
	'=');
	}

	public ResolveTypeSignature(Resolver resovler,
	Map<String, JRealClassType> binaryMapper, TreeLogger logger,
	JType[] returnTypeRef, TypeParameterLookup lookup,
	JClassType enclosingClass, char wildcardMatch) {
	this.resolver = resovler;
	this.binaryMapper = binaryMapper;
	this.logger = logger;
	this.returnTypeRef = returnTypeRef;
	this.lookup = lookup;
	this.enclosingClass = enclosingClass;
	this.wildcardMatch = wildcardMatch;
	}

	@Override
	public SignatureVisitor visitArrayType() {
	++arrayDepth;
	return this;
	}

	@Override
	public void visitBaseType(char descriptor) {
	switch (descriptor) {
	case 'V':
	returnTypeRef[0] = JPrimitiveType.VOID;
	break;
	case 'B':
	returnTypeRef[0] = JPrimitiveType.BYTE;
	break;
	case 'J':
	returnTypeRef[0] = JPrimitiveType.LONG;
	break;
	case 'Z':
	returnTypeRef[0] = JPrimitiveType.BOOLEAN;
	break;
	case 'I':
	returnTypeRef[0] = JPrimitiveType.INT;
	break;
	case 'S':
	returnTypeRef[0] = JPrimitiveType.SHORT;
	break;
	case 'C':
	returnTypeRef[0] = JPrimitiveType.CHAR;
	break;
	case 'F':
	returnTypeRef[0] = JPrimitiveType.FLOAT;
	break;
	case 'D':
	returnTypeRef[0] = JPrimitiveType.DOUBLE;
	break;
	default:
	throw new IllegalStateException("Unrecognized base type " + descriptor);
	}
	// this is the last visitor called on this visitor
	visitEnd();
	}

	@Override
	public void visitClassType(String internalName) {
	assert Name.isInternalName(internalName);
	outerClass = enclosingClass;
	JRealClassType classType = binaryMapper.get(internalName);
	// TODO(jat): failures here are likely binary-only annotations or local
	// classes that have been elided from TypeOracle -- what should we do in
	// those cases? Currently we log an error and replace them with Object,
	// but we may can do something better.
	boolean resolveSuccess = classType == null ? false : resolver.resolveClass(
	logger, classType);
	returnTypeRef[0] = classType;
	if (!resolveSuccess \|\| returnTypeRef[0] == null) {
	logger.log(TreeLogger.ERROR, "Unable to resolve class " + internalName);
	// Replace bound with Object if we can't resolve the class.
	returnTypeRef[0] = resolver.getTypeOracle().getJavaLangObject();
	}
	}

	@Override
	public void visitEnd() {
	if (returnTypeRef[0] == null) {
	return;
	}
	resolveGenerics();
	}

	@Override
	public void visitInnerClassType(String innerName) {
	// Called after visitClass has already been called, and we will
	// successively refine the class by going into its inner classes.
	assert returnTypeRef[0] != null;
	resolveGenerics();
	outerClass = (JClassType) returnTypeRef[0];
	JClassType searchClass = outerClass;
	try {
	JParameterizedType pt = searchClass.isParameterized();
	if (pt != null) {
	searchClass = pt.getBaseType();
	}
	returnTypeRef[0] = searchClass.getNestedType(innerName);
	} catch (NotFoundException e) {
	logger.log(TreeLogger.ERROR, "Unable to resolve inner class " + innerName
	+ " in " + searchClass, e);
	}
	}

	@Override
	public void visitTypeArgument() {
	JType[] arg = new JType[1]; // This could be int[] for example
	arg[0] = resolver.getTypeOracle().getWildcardType(
	JWildcardType.BoundType.UNBOUND,
	resolver.getTypeOracle().getJavaLangObject());
	args.add(arg);
	}

	@Override
	public SignatureVisitor visitTypeArgument(char wildcard) {
	JType[] arg = new JType[1];
	args.add(arg);
	// TODO(jat): should we pass enclosingClass here instead of null?
	// not sure what the enclosing class of a type argument means, but
	// I haven't found a case where it is actually used while processing
	// the type argument.
	return new ResolveTypeSignature(resolver, binaryMapper, logger, arg,
	lookup, null, wildcard);
	}

	@Override
	public void visitTypeVariable(String name) {
	returnTypeRef[0] = lookup.lookup(name);
	// this is the last visitor called on this visitor
	visitEnd();
	}

	/**
	* Merge the bounds from the declared type parameters into the type arguments
	* for this type if necessary.
	*
	* <pre>
	* Example:
	* class Foo<T extends Bar> ...
	*
	* Foo<?> foo
	*
	* foo needs to have bounds ? extends Bar.
	* </pre>
	*
	* <p>
	* Currently we only deal with unbound wildcards as above, which matches
	* existing TypeOracleMediator behavior. However, this may need to be
	* extended.
	*
	* @param typeParams
	* @param typeArgs
	*/
	private void mergeTypeParamBounds(JTypeParameter[] typeParams,
	JClassType[] typeArgs) {
	int n = typeArgs.length;
	for (int i = 0; i < n; ++i) {
	JWildcardType wildcard = typeArgs[i].isWildcard();
	// right now we only replace Foo<?> with the constraints defined on the
	// definition (which appears to match the existing TypeOracleMediator)
	// but other cases may need to be handled.
	if (wildcard != null
	&& wildcard.getBoundType() == BoundType.UNBOUND
	&& wildcard.getBaseType() == resolver.getTypeOracle().getJavaLangObject()
	&& typeParams[i].getBaseType() != null) {
	typeArgs[i] = resolver.getTypeOracle().getWildcardType(
	BoundType.UNBOUND, typeParams[i].getBaseType());
	}
	}
	}

	private JType resolveGeneric(JType type, JClassType outer,
	JClassType[] typeArgs) {
	JGenericType genericType = (JGenericType) type.isGenericType();
	if (genericType != null) {
	int actual = typeArgs.length;
	JTypeParameter[] typeParams = genericType.getTypeParameters();
	int expected = typeParams.length;
	if (actual == 0 && expected > 0) {
	// If no type parameters were supplied, this is a raw type usage.
	type = genericType.getRawType();
	} else {
	if (actual != expected) {
	throw new IllegalStateException("Incorrect # of type parameters to "
	+ genericType.getQualifiedBinaryName() + ": expected " + expected
	+ ", actual=" + actual);
	}
	JClassType genericEnc = genericType.getEnclosingType();
	if (outer == null && genericEnc != null) {
	// Sometimes the signature is like Foo$Bar<H> even if Foo is a
	// generic class. The cases I have seen are where Foo's type
	// parameter is also named H and has the same bounds. That
	// manifests itself as getting visitClassType("Foo$Bar") and
	// then VisitTypeArgument/etc, rather than the usual
	// visitClassType("Foo"), visitTypeArgument/etc,
	// visitInnerClass("Bar"), visitTypeArgument/etc.
	//
	// So, in this case we have to build our own chain of enclosing
	// classes here, properly parameterizing any generics along the
	// way.
	// TODO(jat): more testing to validate this assumption
	JClassType[] outerArgs = null;
	JGenericType genericEncGeneric = genericEnc.isGenericType();
	if (genericEncGeneric != null) {
	JTypeParameter[] encTypeParams = genericEncGeneric.getTypeParameters();
	int n = encTypeParams.length;
	outerArgs = new JClassType[n];
	for (int i = 0; i < n; ++i) {
	outerArgs[i] = lookup.lookup(encTypeParams[i].getName());
	if (outerArgs[i] == null) {
	// check to see if our current type has a parameter of the same
	// name, and use it if so.
	for (int j = 0; j < expected; ++j) {
	if (typeParams[j].getName().equals(encTypeParams[j].getName())) {
	outerArgs[i] = typeArgs[j];
	break;
	}
	}
	}
	assert outerArgs[i] != null : "Unable to resolve type parameter "
	+ encTypeParams[i].getName() + " in enclosing type "
	+ genericEnc + " of type " + genericType;
	}
	}
	outer = (JClassType) resolveGeneric(genericEnc, null, outerArgs);
	}
	try {
	mergeTypeParamBounds(typeParams, typeArgs);
	type = resolver.getTypeOracle().getParameterizedType(genericType,
	outer, typeArgs);
	} catch (IllegalArgumentException e) {
	// Can't use toString on typeArgs as they aren't completely built
	// yet, so we have to roll our own.
	StringBuilder buf = new StringBuilder();
	buf.append("Unable to build parameterized type ");
	buf.append(genericType);
	String prefix = " with args <";
	for (JClassType typeArg : typeArgs) {
	buf.append(prefix).append(typeArg.getName());
	prefix = ", ";
	}
	if (", ".equals(prefix)) {
	buf.append('>');
	}
	logger.log(TreeLogger.ERROR, buf.toString(), e);
	type = genericType.getRawType();
	}
	}
	}
	return type;
	}

	private void resolveGenerics() {
	JGenericType genericType = (JGenericType) returnTypeRef[0].isGenericType();
	if (genericType != null) {
	int actual = args.size();
	JClassType[] typeArgs = new JClassType[actual];
	for (int i = 0; i < actual; ++i) {
	JType type = args.get(i)[0];
	if (!(type instanceof JClassType)) {
	logger.log(TreeLogger.ERROR, "Parameterized type argument is " + type
	+ ", expected reference type");
	} else {
	typeArgs[i] = (JClassType) type;
	}
	}
	returnTypeRef[0] = resolveGeneric(genericType, outerClass, typeArgs);
	args.clear();
	}
	for (int i = 0; i < arrayDepth; ++i) {
	returnTypeRef[0] = resolver.getTypeOracle().getArrayType(returnTypeRef[0]);
	}
	switch (wildcardMatch) {
	case '=':
	// nothing to do for an exact match
	break;
	case '*':
	returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
	JWildcardType.BoundType.UNBOUND, (JClassType) returnTypeRef[0]);
	break;
	case '+':
	// ? extends T
	returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
	JWildcardType.BoundType.EXTENDS, (JClassType) returnTypeRef[0]);
	break;
	case '-':
	// ? super T
	returnTypeRef[0] = resolver.getTypeOracle().getWildcardType(
	JWildcardType.BoundType.SUPER, (JClassType) returnTypeRef[0]);
	break;
	}
	if (returnTypeRef[0] instanceof JClassType) {
	// Only JClassTypes can be an outer class
	outerClass = (JClassType) returnTypeRef[0];
	}
	}
	}