2.4/dev/core/test/com/google/gwt/dev/javac/asm/ResolveGenericsTest.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.JType;
 import com.google.gwt.dev.asm.Opcodes;
 import com.google.gwt.dev.asm.Type;
 import com.google.gwt.dev.asm.signature.SignatureReader;
 import com.google.gwt.dev.javac.MethodArgNamesLookup;
 import com.google.gwt.dev.javac.Resolver;
 import com.google.gwt.dev.javac.TypeOracleMediator;
 import com.google.gwt.dev.javac.TypeOracleTestingUtils;
 import com.google.gwt.dev.javac.TypeParameterLookup;
 import com.google.gwt.dev.javac.asm.CollectClassData.ClassType;
 import com.google.gwt.dev.javac.typemodel.JAbstractMethod;
 import com.google.gwt.dev.javac.typemodel.JClassType;
 import com.google.gwt.dev.javac.typemodel.JGenericType;
 import com.google.gwt.dev.javac.typemodel.JMethod;
 import com.google.gwt.dev.javac.typemodel.JPackage;
 import com.google.gwt.dev.javac.typemodel.JRealClassType;
 import com.google.gwt.dev.javac.typemodel.JTypeParameter;
 import com.google.gwt.dev.javac.typemodel.TypeOracle;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.TypeVariable;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Tests for {@link ResolveClassSignature} and {@link ResolveMethodSignature}.
  */
 public class ResolveGenericsTest extends AsmTestCase {

   public static class FailErrorTreeLogger extends TreeLogger {
     @Override
     public TreeLogger branch(com.google.gwt.core.ext.TreeLogger.Type type,
         String msg, Throwable caught, HelpInfo helpInfo) {
       if (type == TreeLogger.ERROR) {
         fail(msg);
       }
       return this;
     }

     @Override
     public boolean isLoggable(com.google.gwt.core.ext.TreeLogger.Type type) {
       return true;
     }

     @Override
     public void log(com.google.gwt.core.ext.TreeLogger.Type type, String msg,
         Throwable caught, HelpInfo helpInfo) {
       if (type == TreeLogger.ERROR) {
         fail(msg);
       }
     }
   }

   private class MockResolver implements Resolver {
     private final Resolver delegate;

     public MockResolver(Resolver resolver) {
       this.delegate = resolver;
     }

     public void addImplementedInterface(JRealClassType type, JClassType intf) {
       delegate.addImplementedInterface(type, intf);
     }

     public void addThrows(JAbstractMethod method, JClassType exception) {
       delegate.addThrows(method, exception);
     }

     public Map<String, JRealClassType> getBinaryMapper() {
       return delegate.getBinaryMapper();
     }

     public TypeOracle getTypeOracle() {
       return delegate.getTypeOracle();
     }

     public JMethod newMethod(JClassType type, String name,
         Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
         JTypeParameter[] typeParams) {
       return delegate.newMethod(type, name, declaredAnnotations, typeParams);
     }

     public void newParameter(JAbstractMethod method, JType argType,
         String argName,
         Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
         boolean argNamesAreReal) {
       delegate.newParameter(method, argType, argName, declaredAnnotations,
           argNamesAreReal);
     }

     public JRealClassType newRealClassType(JPackage pkg,
         String enclosingTypeName, boolean isLocalType, String className,
         boolean isIntf) {
       return delegate.newRealClassType(pkg, enclosingTypeName, isLocalType,
           className, isIntf);
     }

     public boolean resolveAnnotation(TreeLogger logger,
         CollectAnnotationData annotVisitor,
         Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
       return true;
     }

     public boolean resolveAnnotations(TreeLogger logger,
         List<CollectAnnotationData> annotations,
         Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
       return true;
     }

     public boolean resolveClass(TreeLogger logger, JRealClassType type) {
       return true;
     }

     public void setReturnType(JAbstractMethod method, JType returnType) {
       delegate.setReturnType(method, returnType);
     }

     public void setSuperClass(JRealClassType type, JClassType superType) {
       delegate.setSuperClass(type, superType);
     }
   }

   private static final TreeLogger failTreeLogger = new FailErrorTreeLogger();

   private static final String OUTER_CLASS_SIG = "<H:Lcom/google/gwt/dev/javac/asm/TestHandler;>Ljava/lang/Object;";
   private static final String OUTER_METHOD_SIG = "(TH;)V";

   private static final String OUTER1_CLASS_SIG = "<V:Ljava/lang/Object;>Lcom/google/gwt/dev/javac/asm/TestOuter0<"
       + "Lcom/google/gwt/dev/javac/asm/TestHandler1<TV;>;>;";
   private static final String OUTER1_METHOD_SIG = "(Lcom/google/gwt/dev/javac/asm/TestHandler1<TV;>;)V";

   private static final String OUTER2_CLASS_SIG = "Lcom/google/gwt/dev/javac/asm/TestOuter1<Ljava/lang/String;>;";
   private static final String OUTER2_METHOD_SIG = "(Lcom/google/gwt/dev/javac/asm/TestHandler1<Ljava/lang/String;>;)V";

   private final TypeOracleMediator mediator;

   private final TypeOracle oracle;

   private final Map<JMethod, Method> reflectionMethods = new IdentityHashMap<JMethod, Method>();

   private final MockResolver resolver;

   @SuppressWarnings("unused")
   private final JRealClassType testHandler;
   @SuppressWarnings("unused")
   private final JRealClassType testHandler1;

   private final JRealClassType testOuter0;
   private final JMethod testOuter0dispatch;
   private final JRealClassType testOuter1;

   private final JMethod testOuter1dispatch;
   private final JRealClassType testOuter2;
   private final JMethod testOuter2dispatch;

   @SuppressWarnings("unused")
   private final JRealClassType testType;

   public ResolveGenericsTest() {
     mediator = TypeOracleTestingUtils.buildStandardMediatorWith(failTreeLogger);
     resolver = new MockResolver(mediator.getMockResolver());
     oracle = mediator.getTypeOracle();
     createUnresolvedClass(String.class, null);
     testHandler = createUnresolvedClass(TestHandler.class, null);
     testHandler1 = createUnresolvedClass(TestHandler1.class, null);
     testOuter0 = createUnresolvedClass(TestOuter0.class, null);
     testType = createUnresolvedClass(TestOuter0.Type.class, testOuter0);
     testOuter1 = createUnresolvedClass(TestOuter1.class, null);
     testOuter2 = createUnresolvedClass(TestOuter2.class, null);
     testOuter0dispatch = createUnresolvedMethod(testOuter0, TestOuter0.class,
         "dispatch", TestHandler.class);
     testOuter1dispatch = createUnresolvedMethod(testOuter1, TestOuter1.class,
         "dispatch", TestHandler.class);
     testOuter2dispatch = createUnresolvedMethod(testOuter2, TestOuter2.class,
         "dispatch", TestHandler.class);
     for (JClassType type : oracle.getTypes()) {
       if (type instanceof JRealClassType) {
         mediator.getBinaryMapper().put(
             type.getQualifiedBinaryName().replace('.', '/'),
             (JRealClassType) type);
       }
     }
   }

   public void testOuter0Class() {
     resolveClassSignature(testOuter0, OUTER_CLASS_SIG);
     assertNotNull(testOuter0.getSuperclass());
     // TODO(jat): additional checks?
   }

   public void testOuter0Method() {
     resolveMethodSignature(testOuter0dispatch, OUTER_METHOD_SIG);
     // TODO(jat): meaningful tests besides no errors?
   }

   public void testOuter1Class() {
     resolveClassSignature(testOuter1, OUTER1_CLASS_SIG);
     JClassType superClass = testOuter1.getSuperclass();
     assertNotNull(superClass);
     assertNotNull(superClass.isParameterized());
     // TODO(jat): additional checks?
   }

   public void testOuter1Method() {
     resolveMethodSignature(testOuter1dispatch, OUTER1_METHOD_SIG);
     // TODO(jat): meaningful tests besides no errors?
   }

   public void testOuter2Class() {
     resolveClassSignature(testOuter2, OUTER2_CLASS_SIG);
     JClassType superClass = testOuter2.getSuperclass();
     assertNotNull(superClass);
     assertNotNull(superClass.isParameterized());
     // TODO(jat): additional checks?
   }

   public void testOuter2Method() {
     resolveMethodSignature(testOuter2dispatch, OUTER2_METHOD_SIG);
     // TODO(jat): meaningful tests besides no errors?
   }

   private JTypeParameter[] createTypeParams(TypeVariable<?>[] typeParams) {
     int n = typeParams.length;
     JTypeParameter[] params = new JTypeParameter[n];
     for (int i = 0; i < n; ++i) {
       params[i] = new JTypeParameter(typeParams[i].getName(), i);
     }
     return params;
   }

   private JRealClassType createUnresolvedClass(Class<?> clazz,
       JRealClassType enclosingType) {
     String pkgName = clazz.getPackage().getName();
     JPackage pkg = oracle.getOrCreatePackage(pkgName);
     TypeVariable<?>[] typeParams = clazz.getTypeParameters();
     JRealClassType type;
     int n = typeParams.length;
     String enclosingTypeName = null;
     if (enclosingType != null) {
       enclosingTypeName = enclosingType.getName();
     }
     if (n == 0) {
       type = resolver.newRealClassType(pkg, enclosingTypeName, false,
           clazz.getSimpleName(), clazz.isInterface());
     } else {
       JTypeParameter[] params = createTypeParams(typeParams);
       type = new JGenericType(oracle, pkg, enclosingTypeName,
           clazz.getSimpleName(), clazz.isInterface(), params);
     }
     return type;
   }

   private JMethod createUnresolvedMethod(JClassType type, Class<?> clazz,
       String methodName, Class<?>... paramTypes) {
     Method method = null;
     try {
       method = clazz.getMethod(methodName, paramTypes);
     } catch (SecurityException e) {
       fail("Exception " + e + " creating method " + methodName + " on " + clazz);
     } catch (NoSuchMethodException e) {
       fail("Exception " + e + " creating method " + methodName + " on " + clazz);
     }
     JTypeParameter[] typeParams = createTypeParams(method.getTypeParameters());
     Map<Class<? extends Annotation>, Annotation> emptyMap = Collections.emptyMap();
     JMethod result = resolver.newMethod(type, methodName, emptyMap, typeParams);
     reflectionMethods.put(result, method);
     return result;
   }

   private void resolveClassSignature(JRealClassType type, String signature) {
     Map<String, JRealClassType> binaryMapper = resolver.getBinaryMapper();
     TypeParameterLookup lookup = new TypeParameterLookup();
     lookup.pushEnclosingScopes(type);
     ResolveClassSignature classResolver = new ResolveClassSignature(resolver,
         binaryMapper, failTreeLogger, type, lookup);
     new SignatureReader(signature).accept(classResolver);
     classResolver.finish();
   }

   private void resolveMethodSignature(JMethod method, String signature) {
     TypeParameterLookup lookup = new TypeParameterLookup();
     lookup.pushEnclosingScopes(method.getEnclosingType());
     lookup.pushScope(method.getTypeParameters());
     int access = Opcodes.ACC_PUBLIC;
     Method reflectionMethod = reflectionMethods.get(method);
     String desc = Type.getMethodDescriptor(reflectionMethod);
     CollectMethodData methodData = new CollectMethodData(ClassType.TopLevel,
         access, method.getName(), desc, signature, null);
     Class<?>[] paramTypes = reflectionMethod.getParameterTypes();
     int n = paramTypes.length;
     Type[] argTypes = new Type[n];
     String[] argNames = new String[n];
     for (int i = 0; i < n; ++i) {
       argNames[i] = "arg" + i;
       argTypes[i] = Type.getType(paramTypes[i]);
     }
     ResolveMethodSignature methodResolver = new ResolveMethodSignature(
         resolver, failTreeLogger, method, lookup, true, methodData, argTypes,
         argNames, false, new MethodArgNamesLookup());
     new SignatureReader(signature).accept(methodResolver);
     methodResolver.finish();
   }
 }
	/*
	* 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.JType;
	import com.google.gwt.dev.asm.Opcodes;
	import com.google.gwt.dev.asm.Type;
	import com.google.gwt.dev.asm.signature.SignatureReader;
	import com.google.gwt.dev.javac.MethodArgNamesLookup;
	import com.google.gwt.dev.javac.Resolver;
	import com.google.gwt.dev.javac.TypeOracleMediator;
	import com.google.gwt.dev.javac.TypeOracleTestingUtils;
	import com.google.gwt.dev.javac.TypeParameterLookup;
	import com.google.gwt.dev.javac.asm.CollectClassData.ClassType;
	import com.google.gwt.dev.javac.typemodel.JAbstractMethod;
	import com.google.gwt.dev.javac.typemodel.JClassType;
	import com.google.gwt.dev.javac.typemodel.JGenericType;
	import com.google.gwt.dev.javac.typemodel.JMethod;
	import com.google.gwt.dev.javac.typemodel.JPackage;
	import com.google.gwt.dev.javac.typemodel.JRealClassType;
	import com.google.gwt.dev.javac.typemodel.JTypeParameter;
	import com.google.gwt.dev.javac.typemodel.TypeOracle;

	import java.lang.annotation.Annotation;
	import java.lang.reflect.Method;
	import java.lang.reflect.TypeVariable;
	import java.util.Collections;
	import java.util.IdentityHashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* Tests for {@link ResolveClassSignature} and {@link ResolveMethodSignature}.
	*/
	public class ResolveGenericsTest extends AsmTestCase {

	public static class FailErrorTreeLogger extends TreeLogger {
	@Override
	public TreeLogger branch(com.google.gwt.core.ext.TreeLogger.Type type,
	String msg, Throwable caught, HelpInfo helpInfo) {
	if (type == TreeLogger.ERROR) {
	fail(msg);
	}
	return this;
	}

	@Override
	public boolean isLoggable(com.google.gwt.core.ext.TreeLogger.Type type) {
	return true;
	}

	@Override
	public void log(com.google.gwt.core.ext.TreeLogger.Type type, String msg,
	Throwable caught, HelpInfo helpInfo) {
	if (type == TreeLogger.ERROR) {
	fail(msg);
	}
	}
	}

	private class MockResolver implements Resolver {
	private final Resolver delegate;

	public MockResolver(Resolver resolver) {
	this.delegate = resolver;
	}

	public void addImplementedInterface(JRealClassType type, JClassType intf) {
	delegate.addImplementedInterface(type, intf);
	}

	public void addThrows(JAbstractMethod method, JClassType exception) {
	delegate.addThrows(method, exception);
	}

	public Map<String, JRealClassType> getBinaryMapper() {
	return delegate.getBinaryMapper();
	}

	public TypeOracle getTypeOracle() {
	return delegate.getTypeOracle();
	}

	public JMethod newMethod(JClassType type, String name,
	Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
	JTypeParameter[] typeParams) {
	return delegate.newMethod(type, name, declaredAnnotations, typeParams);
	}

	public void newParameter(JAbstractMethod method, JType argType,
	String argName,
	Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
	boolean argNamesAreReal) {
	delegate.newParameter(method, argType, argName, declaredAnnotations,
	argNamesAreReal);
	}

	public JRealClassType newRealClassType(JPackage pkg,
	String enclosingTypeName, boolean isLocalType, String className,
	boolean isIntf) {
	return delegate.newRealClassType(pkg, enclosingTypeName, isLocalType,
	className, isIntf);
	}

	public boolean resolveAnnotation(TreeLogger logger,
	CollectAnnotationData annotVisitor,
	Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
	return true;
	}

	public boolean resolveAnnotations(TreeLogger logger,
	List<CollectAnnotationData> annotations,
	Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
	return true;
	}

	public boolean resolveClass(TreeLogger logger, JRealClassType type) {
	return true;
	}

	public void setReturnType(JAbstractMethod method, JType returnType) {
	delegate.setReturnType(method, returnType);
	}

	public void setSuperClass(JRealClassType type, JClassType superType) {
	delegate.setSuperClass(type, superType);
	}
	}

	private static final TreeLogger failTreeLogger = new FailErrorTreeLogger();

	private static final String OUTER_CLASS_SIG = "<H:Lcom/google/gwt/dev/javac/asm/TestHandler;>Ljava/lang/Object;";
	private static final String OUTER_METHOD_SIG = "(TH;)V";

	private static final String OUTER1_CLASS_SIG = "<V:Ljava/lang/Object;>Lcom/google/gwt/dev/javac/asm/TestOuter0<"
	+ "Lcom/google/gwt/dev/javac/asm/TestHandler1<TV;>;>;";
	private static final String OUTER1_METHOD_SIG = "(Lcom/google/gwt/dev/javac/asm/TestHandler1<TV;>;)V";

	private static final String OUTER2_CLASS_SIG = "Lcom/google/gwt/dev/javac/asm/TestOuter1<Ljava/lang/String;>;";
	private static final String OUTER2_METHOD_SIG = "(Lcom/google/gwt/dev/javac/asm/TestHandler1<Ljava/lang/String;>;)V";

	private final TypeOracleMediator mediator;

	private final TypeOracle oracle;

	private final Map<JMethod, Method> reflectionMethods = new IdentityHashMap<JMethod, Method>();

	private final MockResolver resolver;

	@SuppressWarnings("unused")
	private final JRealClassType testHandler;
	@SuppressWarnings("unused")
	private final JRealClassType testHandler1;

	private final JRealClassType testOuter0;
	private final JMethod testOuter0dispatch;
	private final JRealClassType testOuter1;

	private final JMethod testOuter1dispatch;
	private final JRealClassType testOuter2;
	private final JMethod testOuter2dispatch;

	@SuppressWarnings("unused")
	private final JRealClassType testType;

	public ResolveGenericsTest() {
	mediator = TypeOracleTestingUtils.buildStandardMediatorWith(failTreeLogger);
	resolver = new MockResolver(mediator.getMockResolver());
	oracle = mediator.getTypeOracle();
	createUnresolvedClass(String.class, null);
	testHandler = createUnresolvedClass(TestHandler.class, null);
	testHandler1 = createUnresolvedClass(TestHandler1.class, null);
	testOuter0 = createUnresolvedClass(TestOuter0.class, null);
	testType = createUnresolvedClass(TestOuter0.Type.class, testOuter0);
	testOuter1 = createUnresolvedClass(TestOuter1.class, null);
	testOuter2 = createUnresolvedClass(TestOuter2.class, null);
	testOuter0dispatch = createUnresolvedMethod(testOuter0, TestOuter0.class,
	"dispatch", TestHandler.class);
	testOuter1dispatch = createUnresolvedMethod(testOuter1, TestOuter1.class,
	"dispatch", TestHandler.class);
	testOuter2dispatch = createUnresolvedMethod(testOuter2, TestOuter2.class,
	"dispatch", TestHandler.class);
	for (JClassType type : oracle.getTypes()) {
	if (type instanceof JRealClassType) {
	mediator.getBinaryMapper().put(
	type.getQualifiedBinaryName().replace('.', '/'),
	(JRealClassType) type);
	}
	}
	}

	public void testOuter0Class() {
	resolveClassSignature(testOuter0, OUTER_CLASS_SIG);
	assertNotNull(testOuter0.getSuperclass());
	// TODO(jat): additional checks?
	}

	public void testOuter0Method() {
	resolveMethodSignature(testOuter0dispatch, OUTER_METHOD_SIG);
	// TODO(jat): meaningful tests besides no errors?
	}

	public void testOuter1Class() {
	resolveClassSignature(testOuter1, OUTER1_CLASS_SIG);
	JClassType superClass = testOuter1.getSuperclass();
	assertNotNull(superClass);
	assertNotNull(superClass.isParameterized());
	// TODO(jat): additional checks?
	}

	public void testOuter1Method() {
	resolveMethodSignature(testOuter1dispatch, OUTER1_METHOD_SIG);
	// TODO(jat): meaningful tests besides no errors?
	}

	public void testOuter2Class() {
	resolveClassSignature(testOuter2, OUTER2_CLASS_SIG);
	JClassType superClass = testOuter2.getSuperclass();
	assertNotNull(superClass);
	assertNotNull(superClass.isParameterized());
	// TODO(jat): additional checks?
	}

	public void testOuter2Method() {
	resolveMethodSignature(testOuter2dispatch, OUTER2_METHOD_SIG);
	// TODO(jat): meaningful tests besides no errors?
	}

	private JTypeParameter[] createTypeParams(TypeVariable<?>[] typeParams) {
	int n = typeParams.length;
	JTypeParameter[] params = new JTypeParameter[n];
	for (int i = 0; i < n; ++i) {
	params[i] = new JTypeParameter(typeParams[i].getName(), i);
	}
	return params;
	}

	private JRealClassType createUnresolvedClass(Class<?> clazz,
	JRealClassType enclosingType) {
	String pkgName = clazz.getPackage().getName();
	JPackage pkg = oracle.getOrCreatePackage(pkgName);
	TypeVariable<?>[] typeParams = clazz.getTypeParameters();
	JRealClassType type;
	int n = typeParams.length;
	String enclosingTypeName = null;
	if (enclosingType != null) {
	enclosingTypeName = enclosingType.getName();
	}
	if (n == 0) {
	type = resolver.newRealClassType(pkg, enclosingTypeName, false,
	clazz.getSimpleName(), clazz.isInterface());
	} else {
	JTypeParameter[] params = createTypeParams(typeParams);
	type = new JGenericType(oracle, pkg, enclosingTypeName,
	clazz.getSimpleName(), clazz.isInterface(), params);
	}
	return type;
	}

	private JMethod createUnresolvedMethod(JClassType type, Class<?> clazz,
	String methodName, Class<?>... paramTypes) {
	Method method = null;
	try {
	method = clazz.getMethod(methodName, paramTypes);
	} catch (SecurityException e) {
	fail("Exception " + e + " creating method " + methodName + " on " + clazz);
	} catch (NoSuchMethodException e) {
	fail("Exception " + e + " creating method " + methodName + " on " + clazz);
	}
	JTypeParameter[] typeParams = createTypeParams(method.getTypeParameters());
	Map<Class<? extends Annotation>, Annotation> emptyMap = Collections.emptyMap();
	JMethod result = resolver.newMethod(type, methodName, emptyMap, typeParams);
	reflectionMethods.put(result, method);
	return result;
	}

	private void resolveClassSignature(JRealClassType type, String signature) {
	Map<String, JRealClassType> binaryMapper = resolver.getBinaryMapper();
	TypeParameterLookup lookup = new TypeParameterLookup();
	lookup.pushEnclosingScopes(type);
	ResolveClassSignature classResolver = new ResolveClassSignature(resolver,
	binaryMapper, failTreeLogger, type, lookup);
	new SignatureReader(signature).accept(classResolver);
	classResolver.finish();
	}

	private void resolveMethodSignature(JMethod method, String signature) {
	TypeParameterLookup lookup = new TypeParameterLookup();
	lookup.pushEnclosingScopes(method.getEnclosingType());
	lookup.pushScope(method.getTypeParameters());
	int access = Opcodes.ACC_PUBLIC;
	Method reflectionMethod = reflectionMethods.get(method);
	String desc = Type.getMethodDescriptor(reflectionMethod);
	CollectMethodData methodData = new CollectMethodData(ClassType.TopLevel,
	access, method.getName(), desc, signature, null);
	Class<?>[] paramTypes = reflectionMethod.getParameterTypes();
	int n = paramTypes.length;
	Type[] argTypes = new Type[n];
	String[] argNames = new String[n];
	for (int i = 0; i < n; ++i) {
	argNames[i] = "arg" + i;
	argTypes[i] = Type.getType(paramTypes[i]);
	}
	ResolveMethodSignature methodResolver = new ResolveMethodSignature(
	resolver, failTreeLogger, method, lookup, true, methodData, argTypes,
	argNames, false, new MethodArgNamesLookup());
	new SignatureReader(signature).accept(methodResolver);
	methodResolver.finish();
	}
	}