Generic working in eclipse compiler but not through builds

Question

The following code snippet works fine in my eclipse development environment (1.6.0_06), but the build system running 1.6.0_06 throws exception:
MyClass:343: incompatible types
found : java.util.List<C>
required: java.util.List<B>
entries = createListFromSmartCopy(myAList, new B(), true);
Types:
A is an interface
B is an interface of A
C is an implementation of B
List<A> aList = new ArrayList<A>();
aList.add(new A());
List<B> return = createListFromSmartCopy(aList, new C(), true);
    * <p>Creates a copy of a list where the source list could be an ancestor
    * type of the returned list. It also uses a reference object to actually
    * construct the objects that populate the return list.</p>
    * @param <T> - The ancestor type of the source list
    * @param <R> - The derived type of the destination list
    * @param <S> - The more derived type of the prototype object used to
    * construct the list of R's
    * @param sourceList - The source list
    * @param referenceObject - The object used to construct the return list
    * @param deepCopy - Deep copy serializable objects instead of just copying
    * the reference
    * @return a list of R's (as defined by the caller) of entries with the
    * object constructed as a copy of referenceObject with the properties of the
    * sourceList copyied in after construction
public static <T extends Serializable, R extends T, S extends R> List<R> createListFromSmartCopy(
            List<T> sourceList, S referenceObject, boolean deepCopy)
      List<R> retr = new ArrayList<R>();
      for(int i = 0; i < sourceList.size(); i++)
         retr.add(copyOf(referenceObject));
         copyInto(sourceList.get(i), retr.get(i), deepCopy);
      return retr;
   }Any thoughts on either:
1. How does this pass the compiler validation inside eclipse, even through 'R' has not been defined? I believe that the code is doing some sort of return type inference to return the exactly correct type of list as referred by the return result or else it is simply ignoring the invariant capture of R all together and silently dropping the error. The funny thing is that the code does work just fine in practice in my development system without an issue.
or
2. Why if the code is valid does the independent build system disallow this generic return type 'inference' to occur? Are there compiler flags I can use to withhold this special condition?

Answer 1

Thanks for the response, I wasn't trying to show a full example but just my implementation's snippet. I'll list one now:
package test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
public class TestMe
    * <p>This method performs a deep copy of an object by serializing and
    * deserialzing the object in question.</p>
    * @param <T> - The type of data to copy
    * @param original - The original object to copy
    * @return The object who's state should be the same as the original. This
    * call uses serialization to guarantee this copy is fully separate from the
    * original, so all sub-object references are also deep copies of their
    * originals
   @SuppressWarnings("unchecked")
   public static <T extends Serializable> T clone(T original)
      T obj = null;
      try
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream out = new ObjectOutputStream(bos);
         out.writeObject(original);
         out.flush();
         out.close();
         ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(
                  bos.toByteArray()));
         obj = (T)in.readObject();
      catch(IOException e)
         e.printStackTrace();
      catch(ClassNotFoundException cnfe)
         cnfe.printStackTrace();
      return obj;
    * <p>Copies the properties from one object to another. The destined object
    * in this method must be derived from the source object. This allows for a
    * faster and smoother transition.</p>
    * @param <T> The type of source
    * @param <R> The type of destination
    * @param source - The source object
    * @param destination - The destination object
    * @param deepCopy - Copies the reference objects instead of just passing
    * back the reference pointer reference
   public static <T, R extends T> void copyInto(T source, R destination,
            boolean deepCopy)
   // Stubbed because it links into a ton of unnecessary methods
    * <p>Copies the values of a list of an ancestor class into the values of
    * another list who's value is derived from the ancestor.</p>
    * @param <T> - The ancestor type of the source list
    * @param <R> - The derived type of the destination list
    * @param sourceList - The source list
    * @param destinationList - The destination list
    * @param deepCopy - Deep copy serializable objects instead of just copying
    * the reference
   public static <T, R extends T> void copyIntoList(List<T> sourceList,
            List<R> destinationList, boolean deepCopy)
      if(sourceList.size() > destinationList.size())
         throw new IllegalArgumentException(
                  "Cannot copy entire source set into destination list");
      for(int i = 0; i < sourceList.size(); i++)
         copyInto(sourceList.get(i), destinationList.get(i), deepCopy);
    * <p>Creates a copy of a list where the source list could be an ancestor
    * type of the returned list. It also uses a reference object to actually
    * construct the objects that populate the return list.</p>
    * @param <T> - The ancestor type of the source list
    * @param <R> - The derived type of the destination list
    * @param <S> - The more derived type of the prototype object used to
    * construct the list of R's
    * @param sourceList - The source list
    * @param referenceObject - The object used to construct the return list
    * @param deepCopy - Deep copy serializable objects instead of just copying
    * the reference
    * @return a list of R's (as defined by the caller) of entries with the
    * object constructed as a copy of referenceObject with the properties of the
    * sourceList copyied in after construction
   public static <T extends Serializable, R extends T, S extends R> List<R> createListFromSmartCopy(
            List<T> sourceList, S referenceObject, boolean deepCopy)
      List<R> retr = new ArrayList<R>();
      for(int i = 0; i < sourceList.size(); i++)
         retr.add(clone(referenceObject));
         copyInto(sourceList.get(i), retr.get(i), deepCopy);
      return retr;
   public static void main(String[] args)
      List<A> aList = new ArrayList<A>();
      aList.add(new AImpl());
      aList.add(new AImpl());
      List<B> bList = createListFromSmartCopy(aList, new C(), true);
      for(B bItem : bList)
         System.out.println("My String = "
                  + bItem.getString() + " and my number = " + bItem.getInt());
   public static interface A extends Serializable
      public void setString(String string);
      public String getString();
   public static class AImpl implements A
      private static final long serialVersionUID = 1L;
      @Override
      public void setString(String string)
      @Override
      public String getString()
         return null;
   public static interface B extends A
      public void setInt(int number);
      public String getInt();
   public static class C implements B
      private static final long serialVersionUID = 1L;
      public C()
      @Override
      public String getInt()
         return null;
      @Override
      public void setInt(int number)
      @Override
      public String getString()
         return null;
      @Override
      public void setString(String string)
}In my eclipse (20090920-1017), this compiles and runs just fine. I stripped out the functional pieces that weren't pertinent to the discussion.