Index: modules/kernel/src/com/caucho/config/reflect/AnnotatedTypeUtil.java
===================================================================
--- modules/kernel/src/com/caucho/config/reflect/AnnotatedTypeUtil.java	(date 1301577825000)
+++ modules/kernel/src/com/caucho/config/reflect/AnnotatedTypeUtil.java	(revision )
@@ -30,6 +30,8 @@
 package com.caucho.config.reflect;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
@@ -41,6 +43,7 @@
 
 import com.caucho.config.inject.InjectManager;
 import com.caucho.inject.Module;
+import com.stendahls.ddt.model.FileCategory;
 
 
 /**
@@ -56,47 +59,90 @@
   {
     return findMethod(type.getMethods(), method);
   }
-  
+
   /**
    * Finds any method matching the method name and parameter types.
    */
   public static <X> AnnotatedMethod<? super X>
-  findMethod(Collection<AnnotatedMethod<? super X>> methodList, 
+  findMethod(Collection<AnnotatedMethod<? super X>> methodList,
              AnnotatedMethod<?> method)
   {
     Method javaMethod = method.getJavaMember();
     String name = javaMethod.getName();
     List<AnnotatedParameter<?>> paramList = (List) method.getParameters();
-    
+
     for (AnnotatedMethod<? super X> testMethod : methodList) {
       Method testJavaMethod = testMethod.getJavaMember();
-      
+
       if (! name.equals(testJavaMethod.getName()))
         continue;
-      
+
       List<AnnotatedParameter<?>> testParamList = (List) testMethod.getParameters();
-      
+
       if (isMatch(paramList, testParamList)) {
         return testMethod;
       }
     }
-    
+
     return null;
   }
-  
+
   private static boolean isMatch(List<AnnotatedParameter<?>> listA,
                                  List<AnnotatedParameter<?>> listB)
   {
     if (listA.size() != listB.size())
       return false;
-    
+
     int len = listA.size();
-    
+
     for (int i = 0; i < len; i++) {
-      if (! listA.get(i).getBaseType().equals(listB.get(i).getBaseType()))
+
+        Type listAType;
+        boolean listATypeIsGeneric = false;
+        if (listA.get(i).getBaseType() instanceof TypeVariable) {
+            listAType = ((TypeVariable) listA.get(i).getBaseType()).getBounds()[0];
+            listATypeIsGeneric = true;
+        }
+        else {
+            listAType = listA.get(i).getBaseType();
+        }
+
+        Type listBType;
+        boolean listBTypeIsGeneric = false;
+        if (listB.get(i).getBaseType() instanceof TypeVariable) {
+            listBType = ((TypeVariable) listB.get(i).getBaseType()).getBounds()[0];
+            listBTypeIsGeneric = true;
+
+        }
+        else {
+            listBType = listB.get(i).getBaseType();
+        }
+
+      if (listATypeIsGeneric && listBTypeIsGeneric) {
-        return false;
-    }
+          return false;
+      }
+      else {
+          if (!listATypeIsGeneric && !listBTypeIsGeneric) {
+              if (!listAType.equals(listBType)) {
+                  return false;
+              }
+          }
+          else {
+              if (listATypeIsGeneric && !listBTypeIsGeneric) {
+                if(!((Class) listAType).isAssignableFrom(((Class) listBType))) {
+                    return false;
+                }
+              }
-    
+
+              if (!listATypeIsGeneric && listBTypeIsGeneric) {
+                if (!((Class) listBType).isAssignableFrom(((Class) listAType))) {
+                    return false;
+                }
+              }
+          }
+      }
+    }
+
     return true;
   }
   /**
@@ -105,7 +151,7 @@
   public static <X> AnnotatedMethod<? super X>
   findMethod(AnnotatedType<X> type, Method javaMethod)
   {
-    return findMethod(type, 
+    return findMethod(type,
                       javaMethod.getName(),
                       javaMethod.getParameterTypes());
   }
@@ -118,14 +164,14 @@
   {
     for (AnnotatedMethod<? super X> annMethod : type.getMethods()) {
       Method method = annMethod.getJavaMember();
-      
+
       if (! method.getName().equals(methodName))
         continue;
-      
+
       if (isMatch(param, method.getParameterTypes()))
         return annMethod;
     }
-    
+
     return null;
   }
 
@@ -137,7 +183,7 @@
   {
     return findMethod(methods, method.getName(), method.getParameterTypes());
   }
-  
+
   /**
    * Finds any method matching the method name and parameter types.
    */
@@ -146,17 +192,17 @@
   {
     for (AnnotatedMethod<? super X> annMethod : methods) {
       Method method = annMethod.getJavaMember();
-      
+
       if (! method.getName().equals(methodName))
         continue;
-      
+
       if (isMatch(param, method.getParameterTypes()))
         return annMethod;
     }
-    
+
     return null;
   }
-  
+
   /**
    * Finds any method matching the method name and parameter types.
    */
@@ -164,16 +210,16 @@
   {
     if (cl == null)
       return null;
-    
+
     for (Method method : cl.getDeclaredMethods()) {
       if (isMatch(method, testMethod))
         return method;
     }
-    
+
     return null;
   }
-  
-  
+
+
   /**
    * Finds any method matching the method name and parameter types.
    */
@@ -183,10 +229,10 @@
       if (isMatch(method, testMethod))
         return method;
     }
-    
+
     return null;
   }
-  
+
   /**
    * Finds any method matching the method name and parameter types.
    */
@@ -196,7 +242,7 @@
       if (isMatch(method, testMethod))
         return method;
     }
-    
+
     return null;
   }
 
@@ -210,31 +256,31 @@
       return true;
     else if (methodA == null || methodB == null)
       return false;
-    
+
     Method javaMethodA = methodA.getJavaMember();
     Method javaMethodB = methodB.getJavaMember();
-    
+
     if (! javaMethodA.getName().equals(javaMethodB.getName()))
       return false;
-    
+
     List<AnnotatedParameter<?>> paramListA = (List) methodA.getParameters();
     List<AnnotatedParameter<?>> paramListB = (List) methodB.getParameters();
-    
+
     if (isMatch(paramListA, paramListB)) {
       return true;
     }
-    
+
     return false;
   }
 
   /**
    * Tests if an annotated method matches a name and parameter types.
    */
-  public static boolean isMatch(AnnotatedMethod<?> method, 
+  public static boolean isMatch(AnnotatedMethod<?> method,
                                 String name, Class<?> []param)
   {
     Method javaMethod = method.getJavaMember();
-    
+
     if (! javaMethod.getName().equals(name))
       return false;
 
@@ -268,7 +314,7 @@
     return isMatch(methodA.getParameterTypes(),
                    methodB.getParameterTypes());
   }
-  
+
   /**
    * Tests if parameters match a method's parameter types.
    */
@@ -276,12 +322,12 @@
   {
     if (paramA.length != paramB.length)
       return false;
-    
+
     for (int i = paramA.length - 1; i >= 0; i--) {
       if (! paramA[i].equals(paramB[i]))
         return false;
     }
-    
+
     return true;
   }
 
Index: modules/resin/src/com/caucho/ejb/gen/SessionGenerator.java
===================================================================
--- modules/resin/src/com/caucho/ejb/gen/SessionGenerator.java	(date 1301577825000)
+++ modules/resin/src/com/caucho/ejb/gen/SessionGenerator.java	(revision )
@@ -35,6 +35,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
@@ -59,14 +60,14 @@
 @Module
 abstract public class SessionGenerator<X> extends BeanGenerator<X> {
   private static final L10N L = new L10N(SessionGenerator.class);
-  
+
   private boolean _hasNoInterfaceView;
 
   private ArrayList<AnnotatedType<? super X>> _localApi;
   private AnnotatedType<X> _localBean;
-  
+
   private ArrayList<AnnotatedType<? super X>> _remoteApi;
-  
+
   private ArrayList<AnnotatedMethod<? super X>> _annotatedMethods
     = new ArrayList<AnnotatedMethod<? super X>>();
 
@@ -74,14 +75,14 @@
 
   private final NonBusinessAspectBeanFactory<X> _nonBusinessAspectBeanFactory;
 
-  private final ArrayList<AspectGenerator<X>> _businessMethods 
+  private final ArrayList<AspectGenerator<X>> _businessMethods
     = new ArrayList<AspectGenerator<X>>();
 
-  public SessionGenerator(String ejbName, 
+  public SessionGenerator(String ejbName,
                           AnnotatedType<X> beanType,
                           ArrayList<AnnotatedType<? super X>> localApi,
                           AnnotatedType<X> localBean,
-                          ArrayList<AnnotatedType<? super X>> remoteApi, 
+                          ArrayList<AnnotatedType<? super X>> remoteApi,
                           String beanTypeName)
   {
     super(toFullClassName(ejbName, beanType.getJavaClass().getName(), beanTypeName),
@@ -94,7 +95,7 @@
 
     _remoteApi = new ArrayList<AnnotatedType<? super X>>(remoteApi);
 
-    _nonBusinessAspectBeanFactory 
+    _nonBusinessAspectBeanFactory
       = new NonBusinessAspectBeanFactory<X>(getBeanType());
  }
 
@@ -104,9 +105,9 @@
     StringBuilder sb = new StringBuilder();
 
     sb.append(className);
-    
+
     sb.append("__");
-    
+
     if (! className.endsWith(ejbName)) {
       for (int i = 0; i < ejbName.length(); i++) {
         char ch = ejbName.charAt(i);
@@ -119,14 +120,14 @@
           sb.append('_');
       }
     }
-    
+
     sb.append(beanType);
     sb.append("Proxy");
 
     return sb.toString();
   }
 
-  public boolean isStateless() 
+  public boolean isStateless()
   {
     return false;
   }
@@ -136,7 +137,7 @@
     // return _hasNoInterfaceView;
     return getLocalBean() != null;
   }
-  
+
   /**
    * Returns the local API list.
    */
@@ -144,7 +145,7 @@
   {
     return _localApi;
   }
-  
+
   public AnnotatedType<X> getLocalBean()
   {
     return _localBean;
@@ -157,7 +158,7 @@
   {
     return _remoteApi;
   }
-  
+
   /**
    * Returns the merged annotated methods
    */
@@ -182,36 +183,36 @@
   public void introspect()
   {
     super.introspect();
-    
-    if (getBeanType().isAnnotationPresent(LocalBean.class) 
+
+    if (getBeanType().isAnnotationPresent(LocalBean.class)
         && ! getBeanType().getJavaClass().isInterface())
       _hasNoInterfaceView = true;
-        
+
     if (_localApi.size() == 0 && _remoteApi.size() == 0)
       _hasNoInterfaceView = true;
 
     if (_hasNoInterfaceView) {
       AnnotatedType<? super X> localDefault = introspectLocalDefault();
-      
+
       if (localDefault.getJavaClass().isInterface())
-        _localApi.add(localDefault); 
+        _localApi.add(localDefault);
       else {
         // we still want to introspect the methods, but don't add it as
         // a local api because it will be treated as an interface later
         introspectType(localDefault);
       }
     }
-    
+
     for (AnnotatedType<? super X> type : _localApi) {
       introspectType(type);
     }
-    
+
     for (AnnotatedType<? super X> type : _remoteApi) {
       introspectType(type);
     }
-    
+
     introspectImpl();
-    
+
     // this comes after the other introspection classes because all it
     // does is catch private timer methods and generate aspect wrappers
     // that wouldn't normally be generated if the method didn't have
@@ -219,24 +220,24 @@
     if (isTimerSupported())
       introspectTimerMethods();
   }
-  
+
   private void introspectType(AnnotatedType<? super X> type)
   {
     for (AnnotatedMethod<? super X> method : type.getMethods()) {
       introspectMethod(method);
     }
   }
-  
+
   private void introspectMethod(AnnotatedMethod<? super X> method)
   {
-    AnnotatedMethod<? super X> oldMethod 
+    AnnotatedMethod<? super X> oldMethod
       = findMethod(_annotatedMethods, method);
-    
+
     if (oldMethod != null) {
       // XXX: merge annotations
       return;
     }
-    
+
     AnnotatedMethod<? super X> baseMethod
       = findMethod(getBeanType().getMethods(), method);
 
@@ -247,7 +248,7 @@
     _annotatedMethods.add(baseMethod);
   }
 
-  
+
   /**
    * Introspects the APIs methods, producing a business method for
    * each.
@@ -258,10 +259,10 @@
       // ejb/5015
       introspectMethodImpl(method);
     }
-    
+
     for (AnnotatedMethod<? super X> method : getBeanType().getMethods()) {
       Method javaMethod = method.getJavaMember();
-      
+
       if (method.isAnnotationPresent(PostConstruct.class)
           && javaMethod.getParameterTypes().length == 0) {
         // ejb/1060 only one post construct
@@ -287,70 +288,70 @@
                                       javaMethod.getDeclaringClass(),
                                       javaMethod.getName()));
       }
-    
+
       int modifiers = javaMethod.getModifiers();
 
       if (! Modifier.isPublic(modifiers) && ! Modifier.isPrivate(modifiers))
         addNonBusinessMethod(apiMethod);
     }
   }
-  
+
   private void introspectTimerMethods()
   {
     for (AnnotatedMethod<? super X> method : getAnnotatedMethods()) {
       introspectTimerMethod(method);
-    }    
+    }
   }
-  
+
   private void introspectTimerMethod(AnnotatedMethod<? super X> apiMethod)
   {
     Method javaMethod = apiMethod.getJavaMember();
-      
+
     int modifiers = javaMethod.getModifiers();
 
-    if (! isBusinessMethod(javaMethod) 
+    if (! isBusinessMethod(javaMethod)
         && ! Modifier.isPublic(modifiers)
         && (javaMethod.isAnnotationPresent(Schedule.class)
             || javaMethod.isAnnotationPresent(Schedules.class))) {
       addScheduledMethod(apiMethod);
     }
   }
-  
+
   protected void addBusinessMethod(AnnotatedMethod<? super X> method)
   {
     AspectGenerator<X> bizMethod = getAspectBeanFactory().create(method);
-      
+
     if (bizMethod != null && ! _businessMethods.contains(bizMethod)) {
       _businessMethods.add(bizMethod);
     }
   }
-  
+
   protected void addPostConstructMethod(AnnotatedMethod<? super X> method)
   {
     if (getLifecycleAspectFactory() == null)
       return;
-    
+
     AspectGenerator<X> initMethod = getLifecycleAspectFactory().create(method);
-      
+
     // ejb/5015
     if (initMethod != null) {
       _businessMethods.add(initMethod);
     }
-    
+
     /*
     if (initMethod != null && ! _businessMethods.contains(initMethod)) {
       _businessMethods.add(initMethod);
     }
     */
   }
-  
+
   protected void addPreDestroyMethod(AnnotatedMethod<? super X> method)
   {
     if (getLifecycleAspectFactory() == null)
       return;
-    
+
     AspectGenerator<X> initMethod = getLifecycleAspectFactory().create(method);
-      
+
     // ejb/5015
     /*
     if (initMethod != null && ! _businessMethods.contains(initMethod)) {
@@ -364,42 +365,76 @@
 
   protected void addNonBusinessMethod(AnnotatedMethod<? super X> method)
   {
-    AspectGenerator<X> nonBizMethod 
+    AspectGenerator<X> nonBizMethod
       = _nonBusinessAspectBeanFactory.create(method);
-      
+
     // XXX seems weird to add this to the _businessMethods, but the generation
     // is correct.
     if (nonBizMethod != null)
       _businessMethods.add(nonBizMethod);
-  } 
+  }
 
   protected void addScheduledMethod(AnnotatedMethod<? super X> method)
   {
-    AspectGenerator<X> bizMethod = 
+    AspectGenerator<X> bizMethod =
       getScheduledAspectBeanFactory().create(method);
-      
+
     if (bizMethod != null)
       _businessMethods.add(bizMethod);
   }
-  
-  private AnnotatedMethod<? super X> 
+
+  private AnnotatedMethod<? super X>
   findMethod(Collection<AnnotatedMethod<? super X>> methodList,
-             AnnotatedMethod<? super X> method)
-  {
-    for (AnnotatedMethod<? super X> oldMethod : methodList) {
-      if (AnnotatedTypeUtil.isMatch(oldMethod, method)) {
-        return oldMethod;
+             AnnotatedMethod<? super X> method) {
+
+        List<AnnotatedMethod<? super X>> methodCandidates = new ArrayList<AnnotatedMethod<? super X>>();
+
+    for (AnnotatedMethod<? super X> baseMethods : methodList) {
+      if (AnnotatedTypeUtil.isMatch(baseMethods, method)) {
+        methodCandidates.add(baseMethods);
       }
     }
-    
+
+    if (methodCandidates.isEmpty()) {
-    return null;
-  }
+        return null;
+    }
+    else {
+        if (methodCandidates.size() == 1) {
+            return methodCandidates.get(0);
+        }
+        else {
+            return estimateClosestCandidate(method, methodCandidates);
+        }
 
+    }
+  }
+
+    private AnnotatedMethod<? super X> estimateClosestCandidate(AnnotatedMethod<? super X> method, List<AnnotatedMethod<? super X>> methodCandidates) {
+        AnnotatedMethod<? super X> nominee = null;
+        int amountOfObjectParameters = 0;
+        for (AnnotatedMethod<? super X> methodCandidate : methodCandidates) {
+
+            int objectParams = 0;
+            for (Class<?> parameterType : methodCandidate.getJavaMember().getParameterTypes()) {
+                if (parameterType.equals(Object.class)) {
+                    objectParams++;
+                }
+            }
+
+            if (nominee == null || objectParams < amountOfObjectParameters) {
+                nominee = methodCandidate;
+                amountOfObjectParameters = objectParams;
+            }
+
+        }
+        return nominee;
+    }
+
-  protected AnnotatedType<? super X> introspectLocalDefault()
+    protected AnnotatedType<? super X> introspectLocalDefault()
   {
     return getBeanType();
   }
-  
+
   protected void generateContentImpl(JavaWriter out,
                                      HashMap<String,Object> map)
     throws IOException
@@ -407,7 +442,7 @@
     generateBeanPrologue(out, map);
 
     generateBusinessMethods(out, map);
-    
+
     generateEpilogue(out, map);
     generateInject(out, map);
     generateDelegate(out, map);
@@ -416,28 +451,28 @@
   }
 
   @Override
-  protected void generatePostConstruct(JavaWriter out, 
+  protected void generatePostConstruct(JavaWriter out,
                                        HashMap<String,Object> map)
      throws IOException
   {
     generatePostConstructImpl(out, map);
   }
- 
+
   protected AspectBeanFactory<X> getScheduledAspectBeanFactory()
   {
     throw new UnsupportedOperationException();
   }
-  
+
   abstract protected boolean isTimerSupported();
   abstract protected AspectBeanFactory<X> getAspectBeanFactory();
-  
+
   protected AspectBeanFactory<X> getLifecycleAspectFactory()
   {
     return null;
   }
-  
+
   // abstract protected void generateBody(JavaWriter out) throws IOException;
-  
+
   public static boolean isBusinessMethod(Method method)
   {
     if (method.getDeclaringClass().equals(Object.class))
@@ -446,15 +481,15 @@
       return false;
     if (method.getName().startsWith("ejb")) {
     }
-    
+
     int modifiers = method.getModifiers();
 
     if (! Modifier.isPublic(modifiers))
       return false;
-    
+
     if (Modifier.isFinal(modifiers) || Modifier.isStatic(modifiers))
       return false;
-    
+
     return true;
   }
 }