diff --git a/dev/build.xml b/dev/build.xml
index 00a5c2b..8af5836 100755
--- a/dev/build.xml
+++ b/dev/build.xml
@@ -41,6 +41,7 @@
         <pathelement location="${gwt.tools.lib}/w3c/sac/sac-1.3.jar" />
         <pathelement location="${gwt.tools.lib}/w3c/flute/flute-1.3-gg1.jar" />
         <pathelement location="${gwt.tools}/redist/json/r2_20080312/json-1.5.jar" />
+        <pathelement location="${gwt.tools.lib}/hibernate/validator/hibernate-validator-4.1.0.Final.jar" />
         <pathelement location="${gwt.tools.lib}/javax/validation/validation-api-1.0.0.GA.jar" />
         <pathelement location="${gwt.build.lib}/gwt-dev-${build.host.platform}.jar" />
         <pathelement location="${alldeps.jar}" />
diff --git a/distro-source/build.xml b/distro-source/build.xml
index 1bb9439..7918e52 100755
--- a/distro-source/build.xml
+++ b/distro-source/build.xml
@@ -22,6 +22,7 @@
       <zipfileset file="${gwt.build.lib}/gwt-dev.jar" prefix="${project.distname}" />
       <zipfileset file="${gwt.build.lib}/gwt-user.jar" prefix="${project.distname}" />
       <zipfileset file="${gwt.build.lib}/gwt-servlet.jar" prefix="${project.distname}" />
+      <zipfileset file="${gwt.build.lib}/gwt-servlet-deps.jar" prefix="${project.distname}" />
       <zipfileset file="${gwt.build.lib}/gwt-benchmark-viewer.war" prefix="${project.distname}" />
       <zipfileset file="${gwt.build.lib}/gwt-soyc-vis.jar" prefix="${project.distname}" />
       <zipfileset file="${gwt.build.lib}/gwt-api-checker.jar" prefix="${project.distname}" />
diff --git a/samples/dynatablerf/src/com/google/gwt/sample/dynatablerf/client/PersonEditorWorkflow.java b/samples/dynatablerf/src/com/google/gwt/sample/dynatablerf/client/PersonEditorWorkflow.java
index 81dae75..51ce66f 100644
--- a/samples/dynatablerf/src/com/google/gwt/sample/dynatablerf/client/PersonEditorWorkflow.java
+++ b/samples/dynatablerf/src/com/google/gwt/sample/dynatablerf/client/PersonEditorWorkflow.java
@@ -97,6 +97,7 @@
         }
       }
     }, KeyUpEvent.getType());
+    this.favorite.setVisible(false);
   }
 
   /**
@@ -156,8 +157,9 @@
   private void edit(RequestContext requestContext) {
     editorDriver = GWT.create(Driver.class);
     editorDriver.initialize(requestFactory, personEditor);
-
+    
     if (requestContext == null) {
+      this.favorite.setVisible(true);
       fetchAndEdit();
       return;
     }
diff --git a/samples/validation/build.xml b/samples/validation/build.xml
index 5f960a7..844f146 100755
--- a/samples/validation/build.xml
+++ b/samples/validation/build.xml
@@ -20,7 +20,9 @@
     <pathelement location="${gwt.tools.lib}/javax/xml/stream/stax-api-1.0-2.jar" />
   </path>
   <fileset id="sample.server.libs" dir="${gwt.tools.lib}">
+    <include name="javax/validation/validation-api-1.0.0.GA-sources.jar" />
     <include name="hibernate/validator/hibernate-validator-4.1.0.Final.jar" />
+    <include name="hibernate/validator/hibernate-validator-4.1.0.Final-sources.jar" />
     <include name="apache/log4j/log4j-1.2.16.jar" />
     <include name="slf4j/slf4j-api/slf4j-api-1.6.1.jar" />
     <include name="slf4j/slf4j-log4j12/slf4j-log4j12-1.6.1.jar" />
diff --git a/servlet/build.xml b/servlet/build.xml
index 6440445..e30dace 100755
--- a/servlet/build.xml
+++ b/servlet/build.xml
@@ -4,12 +4,29 @@
   <import file="${gwt.root}/common.ant.xml" />
 
   <property.ensure name="gwt.user.root" location="${gwt.root}/user" />
+  <property.ensure name="gwt.dev.build" location="${gwt.build.out}/dev" />
   <property.ensure name="gwt.user.build" location="${gwt.build.out}/user" />
+  <property.ensure name="gwt.dev.bin" location="${gwt.dev.build}/bin" />
   <property.ensure name="gwt.user.bin" location="${gwt.user.build}/bin" />
 
-  <target name="build" description="Packages this project into a jar">
+  <property name="project.lib.deps"
+      location="${gwt.build.lib}/gwt-${ant.project.name}-deps.jar" />
+
+  <target name="build" description="Packages this project into a jar"
+      depends="-servlet, -deps" />
+
+  <target name="clean" description="Cleans this project's intermediate and output files">
+    <delete file="${project.lib}" />
+    <delete file="${project.lib.deps}" />
+  </target>
+
+  <target name="-servlet" description="Packages this project into a jar">
     <mkdir dir="${gwt.build.lib}" />
     <gwt.jar>
+      <fileset dir="${gwt.dev.bin}">
+        <include name="com/google/gwt/dev/asm/**" />
+        <include name="com/google/gwt/dev/util/Name*.class" />
+      </fileset>
       <fileset dir="${gwt.user.bin}">
         <exclude name="**/rebind/**" />
         <exclude name="**/tools/**" />
@@ -21,13 +38,15 @@
         <exclude name="com/google/gwt/junit/server/**" />
         <exclude name="com/google/gwt/benchmarks/*" />
       </fileset>
+    </gwt.jar>
+  </target>
+
+  <target name="-deps" description="Packages this project's dependencies into a jar">
+    <mkdir dir="${gwt.build.lib}" />
+    <gwt.jar destfile="${project.lib.deps}">
       <!-- The following two jars satisfy RequestFactory dependencies. -->
       <zipfileset src="${gwt.tools.redist}/json/r2_20080312/json-1.5.jar" />
       <zipfileset src="${gwt.tools.lib}/javax/validation/validation-api-1.0.0.GA.jar" />
     </gwt.jar>
   </target>
-
-  <target name="clean" description="Cleans this project's intermediate and output files">
-    <delete file="${project.lib}" />
-  </target>
 </project>
diff --git a/user/src/com/google/gwt/requestfactory/rebind/model/ContextMethod.java b/user/src/com/google/gwt/requestfactory/rebind/model/ContextMethod.java
index be744e4..9922620 100644
--- a/user/src/com/google/gwt/requestfactory/rebind/model/ContextMethod.java
+++ b/user/src/com/google/gwt/requestfactory/rebind/model/ContextMethod.java
@@ -52,17 +52,12 @@
     public void setRequestMethods(List<RequestMethod> requestMethods) {
       toReturn.requestMethods = requestMethods;
     }
-
-    public void setServiceClass(Class<?> serviceClass) {
-      toReturn.serviceClass = serviceClass;
-    }
   }
 
   private String interfaceName;
   private String methodName;
   private String packageName;
   private List<RequestMethod> requestMethods;
-  private Class<?> serviceClass;
   private String simpleSourceName;
 
   private ContextMethod() {
@@ -95,10 +90,6 @@
     return Collections.unmodifiableList(requestMethods);
   }
 
-  public Class<?> getServiceClass() {
-    return serviceClass;
-  }
-
   public String getSimpleSourceName() {
     return simpleSourceName;
   }
diff --git a/user/src/com/google/gwt/requestfactory/rebind/model/RequestFactoryModel.java b/user/src/com/google/gwt/requestfactory/rebind/model/RequestFactoryModel.java
index 3803b1f..77ce999 100644
--- a/user/src/com/google/gwt/requestfactory/rebind/model/RequestFactoryModel.java
+++ b/user/src/com/google/gwt/requestfactory/rebind/model/RequestFactoryModel.java
@@ -28,13 +28,13 @@
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.InstanceRequest;
 import com.google.gwt.requestfactory.shared.ProxyFor;
+import com.google.gwt.requestfactory.shared.ProxyForName;
 import com.google.gwt.requestfactory.shared.Request;
 import com.google.gwt.requestfactory.shared.RequestContext;
 import com.google.gwt.requestfactory.shared.RequestFactory;
 import com.google.gwt.requestfactory.shared.Service;
+import com.google.gwt.requestfactory.shared.ServiceName;
 
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -159,13 +159,12 @@
   private void buildContextMethod(ContextMethod.Builder contextBuilder,
       JClassType contextType) throws UnableToCompleteException {
     Service serviceAnnotation = contextType.getAnnotation(Service.class);
-    if (serviceAnnotation == null) {
+    ServiceName serviceNameAnnotation = contextType.getAnnotation(ServiceName.class);
+    if (serviceAnnotation == null && serviceNameAnnotation == null) {
       poison("RequestContext subtype %s is missing a @%s annotation",
           contextType.getQualifiedSourceName(), Service.class.getSimpleName());
       return;
     }
-    Class<?> serviceClass = serviceAnnotation.value();
-    contextBuilder.setServiceClass(serviceClass);
 
     List<RequestMethod> requestMethods = new ArrayList<RequestMethod>();
     for (JMethod method : contextType.getInheritableMethods()) {
@@ -177,8 +176,7 @@
       RequestMethod.Builder methodBuilder = new RequestMethod.Builder();
       methodBuilder.setDeclarationMethod(method);
 
-      if (!validateContextMethodAndSetDataType(methodBuilder, method,
-          serviceClass)) {
+      if (!validateContextMethodAndSetDataType(methodBuilder, method)) {
         continue;
       }
 
@@ -193,20 +191,6 @@
     throw new UnableToCompleteException();
   }
 
-  /**
-   * Returns a list of public methods that match the given methodName.
-   */
-  private List<Method> findMethods(Class<?> domainType, String methodName) {
-    List<Method> toReturn = new ArrayList<Method>();
-    for (Method method : domainType.getMethods()) {
-      if (methodName.equals(method.getName())
-          && (method.getModifiers() & Modifier.PUBLIC) != 0) {
-        toReturn.add(method);
-      }
-    }
-    return toReturn;
-  }
-
   private EntityProxyModel getEntityProxyType(JClassType entityProxyType)
       throws UnableToCompleteException {
     entityProxyType = ModelUtils.ensureBaseType(entityProxyType);
@@ -225,16 +209,13 @@
 
       // Get the server domain object type
       ProxyFor proxyFor = entityProxyType.getAnnotation(ProxyFor.class);
-      if (proxyFor == null) {
-        poison("The %s type does not have a @%s annotation",
+      ProxyForName proxyForName = entityProxyType.getAnnotation(ProxyForName.class);
+      if (proxyFor == null && proxyForName == null) {
+        poison("The %s type does not have a @%s or @%s annotation",
             entityProxyType.getQualifiedSourceName(),
-            ProxyFor.class.getSimpleName());
+            ProxyFor.class.getSimpleName(), ProxyForName.class.getSimpleName());
         // early exit, because further processing causes NPEs in numerous spots
         die(poisonedMessage());
-      } else {
-        Class<?> domainType = proxyFor.value();
-        builder.setProxyFor(domainType);
-        validateDomainType(domainType);
       }
 
       // Look at the methods declared on the EntityProxy
@@ -267,9 +248,7 @@
         }
         validateTransportableType(methodBuilder, transportedType, false);
         RequestMethod requestMethod = methodBuilder.build();
-        if (validateDomainBeanMethod(requestMethod, builder)) {
-          requestMethods.add(requestMethod);
-        }
+        requestMethods.add(requestMethod);
       }
       builder.setRequestMethods(requestMethods);
 
@@ -280,20 +259,6 @@
     return toReturn;
   }
 
-  private boolean isStatic(Method domainMethod) {
-    return (domainMethod.getModifiers() & Modifier.STATIC) != 0;
-  }
-
-  private String methodLocation(Method domainMethod) {
-    return domainMethod.getDeclaringClass().getName() + "."
-        + domainMethod.getName();
-  }
-
-  private String methodLocation(JMethod proxyMethod) {
-    return proxyMethod.getEnclosingType().getName() + "."
-        + proxyMethod.getName();
-  }
-
   private void poison(String message, Object... args) {
     logger.log(TreeLogger.ERROR, String.format(message, args));
     poisoned = true;
@@ -303,7 +268,7 @@
    * Examine a RequestContext method to see if it returns a transportable type.
    */
   private boolean validateContextMethodAndSetDataType(
-      RequestMethod.Builder methodBuilder, JMethod method, Class<?> serviceClass)
+      RequestMethod.Builder methodBuilder, JMethod method)
       throws UnableToCompleteException {
     JClassType requestReturnType = method.getReturnType().isInterface();
     JClassType invocationReturnType;
@@ -314,40 +279,13 @@
       return false;
     }
 
-    /*
-     * TODO: bad assumption Implicit assumption is that the Service and ProxyFor
-     * classes are the same. This is because an instance method should
-     * technically be looked up on the class that is the instance parameter, and
-     * not on the serviceClass, which consists of static service methods. Can't
-     * be fixed until it is fixed in JsonRequestProcessor.
-     */
-    Method domainMethod = validateExistsAndNotOverriden(method, serviceClass,
-        false);
-    if (domainMethod == null) {
-      return false;
-    }
-
     if (instanceRequestInterface.isAssignableFrom(requestReturnType)) {
-      if (isStatic(domainMethod)) {
-        poison("Method %s.%s is an instance method, "
-            + "while the corresponding method on %s is static",
-            method.getEnclosingType().getName(), method.getName(),
-            serviceClass.getName());
-        return false;
-      }
       // Instance method invocation
       JClassType[] params = ModelUtils.findParameterizationOf(
           instanceRequestInterface, requestReturnType);
       methodBuilder.setInstanceType(getEntityProxyType(params[0]));
       invocationReturnType = params[1];
     } else if (requestInterface.isAssignableFrom(requestReturnType)) {
-      if (!isStatic(domainMethod)) {
-        poison("Method %s.%s is a static method, "
-            + "while the corresponding method on %s is not",
-            method.getEnclosingType().getName(), method.getName(),
-            serviceClass.getName());
-        return false;
-      }
       // Static method invocation
       JClassType[] params = ModelUtils.findParameterizationOf(requestInterface,
           requestReturnType);
@@ -363,152 +301,14 @@
     // Validate the parameters
     boolean paramsOk = true;
     JParameter[] params = method.getParameters();
-    Class<?>[] domainParams = domainMethod.getParameterTypes();
-    if (params.length != domainParams.length) {
-      poison("Method %s.%s parameters do not match same method on %s",
-          method.getEnclosingType().getName(), method.getName(),
-          serviceClass.getName());
-    }
     for (int i = 0; i < params.length; ++i) {
       JParameter param = params[i];
-      Class<?> domainParam = domainParams[i];
       paramsOk = validateTransportableType(new RequestMethod.Builder(),
           param.getType(), false)
           && paramsOk;
-      paramsOk = validateProxyAndDomainTypeEquals(param.getType(), domainParam,
-          i, methodLocation(method), methodLocation(domainMethod)) && paramsOk;
     }
 
-    return validateTransportableType(methodBuilder, invocationReturnType, true)
-        && validateProxyAndDomainTypeEquals(invocationReturnType,
-            domainMethod.getReturnType(), -1, methodLocation(method),
-            methodLocation(domainMethod)) && paramsOk;
-  }
-
-  /**
-   * Examine a domain method to see if it matches the proxy method.
-   */
-  private boolean validateDomainBeanMethod(RequestMethod requestMethod,
-      EntityProxyModel.Builder entityBuilder) throws UnableToCompleteException {
-    JMethod proxyMethod = requestMethod.getDeclarationMethod();
-    // check if method exists on domain object
-    Class<?> domainType = entityBuilder.peek().getProxyFor();
-    Method domainMethod = validateExistsAndNotOverriden(proxyMethod,
-        domainType, true);
-    if (domainMethod == null) {
-      return false;
-    }
-
-    boolean isGetter = proxyMethod.getName().startsWith("get");
-    if (isGetter) {
-      // compare return type of domain to proxy return type
-      String returnTypeName = domainMethod.getReturnType().getName();
-      // isEntityType() returns true for collections, but we want the Collection
-      String propertyTypeName = requestMethod.isCollectionType()
-          || requestMethod.isValueType()
-          ? requestMethod.getDataType().getQualifiedBinaryName()
-          : requestMethod.getEntityType().getProxyFor().getName();
-      if (!returnTypeName.equals(propertyTypeName)) {
-        poison("Method %s.%s return type %s does not match return type %s "
-            + " of method %s.%s", domainType.getName(), domainMethod.getName(),
-            returnTypeName, propertyTypeName,
-            proxyMethod.getEnclosingType().getName(), proxyMethod.getName());
-        return false;
-      }
-    }
-    JParameter[] proxyParams = proxyMethod.getParameters();
-    Class<?>[] domainParams = domainMethod.getParameterTypes();
-    if (proxyParams.length != domainParams.length) {
-      poison("Method %s.%s parameter mismatch with %s.%s",
-          proxyMethod.getEnclosingType().getName(), proxyMethod.getName(),
-          domainType.getName(), domainMethod.getName());
-      return false;
-    }
-    for (int i = 0; i < proxyParams.length; i++) {
-      JType proxyParam = proxyParams[i].getType();
-      Class<?> domainParam = domainParams[i];
-      if (!validateProxyAndDomainTypeEquals(proxyParam, domainParam, i,
-          methodLocation(proxyMethod), methodLocation(domainMethod))) {
-        poison("Parameter %d of %s.%s doesn't match method %s.%s", i,
-            proxyMethod.getEnclosingType().getName(), proxyMethod.getName(),
-            domainType.getName(), domainMethod.getName());
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Examine a domain type and see if it includes a getId() method.
-   */
-  private boolean validateDomainType(Class<?> domainType) {
-    try {
-      domainType.getMethod("getId");
-    } catch (NoSuchMethodException e) {
-      poison("The class %s is missing method getId()", domainType.getName());
-      return false;
-    }
-    try {
-      domainType.getMethod("getVersion");
-    } catch (NoSuchMethodException e) {
-      poison("The class %s is missing method getVersion()",
-          domainType.getName());
-      return false;
-    }
-    return true;
-  }
-
-  private Method validateExistsAndNotOverriden(JMethod clientMethod,
-      Class<?> serverType, boolean isGetterOrSetter) {
-    List<Method> domainMethods = findMethods(serverType, clientMethod.getName());
-    if (domainMethods.size() == 0) {
-      poison("Method %s.%s has no corresponding public method on %s",
-          clientMethod.getEnclosingType().getQualifiedBinaryName(),
-          clientMethod.getName(), serverType.getName());
-      return null;
-    }
-    if (domainMethods.size() > 1) {
-      poison("Method %s.%s is overloaded on %s",
-          clientMethod.getEnclosingType().getQualifiedBinaryName(),
-          clientMethod.getName(), serverType.getName());
-      return null;
-    }
-    Method domainMethod = domainMethods.get(0);
-    if (isGetterOrSetter && isStatic(domainMethod)) {
-      poison("Method %s.%s is declared static", serverType.getName(),
-          domainMethod.getName());
-      return null;
-    }
-    return domainMethod;
-  }
-
-  /**
-   * Compare type from Proxy and Domain.
-   */
-  private boolean validateProxyAndDomainTypeEquals(JType proxyType,
-      Class<?> domainType, int paramNumber, String clientMethod,
-      String serverMethod) throws UnableToCompleteException {
-    boolean matchOk = false;
-    if (ModelUtils.isValueType(oracle, proxyType)
-        || collectionInterface.isAssignableFrom(proxyType.isClassOrInterface())) {
-      // allow int to match int or Integer
-      matchOk = proxyType.getQualifiedSourceName().equals(
-          ModelUtils.maybeAutobox(domainType).getName())
-          || proxyType.getQualifiedSourceName().equals(domainType.getName());
-    } else {
-      matchOk = getEntityProxyType(proxyType.isClassOrInterface()).getProxyFor().equals(
-          domainType);
-    }
-    if (!matchOk) {
-      if (paramNumber < 0) {
-        poison("Return type of method %s does not match method %s",
-            clientMethod, serverMethod);
-      } else {
-        poison("Parameter %d of method %s does not match method %s",
-            paramNumber, clientMethod, serverMethod);
-      }
-    }
-    return matchOk;
+    return validateTransportableType(methodBuilder, invocationReturnType, true);
   }
 
   /**
diff --git a/user/src/com/google/gwt/requestfactory/server/DefaultSecurityProvider.java b/user/src/com/google/gwt/requestfactory/server/DefaultSecurityProvider.java
index 7b60641..cdcb90f 100644
--- a/user/src/com/google/gwt/requestfactory/server/DefaultSecurityProvider.java
+++ b/user/src/com/google/gwt/requestfactory/server/DefaultSecurityProvider.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2010 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
@@ -16,25 +16,31 @@
 package com.google.gwt.requestfactory.server;
 
 import com.google.gwt.requestfactory.shared.Service;
+import com.google.gwt.requestfactory.shared.ServiceName;
 
 /**
  * A security provider that enforces
  * {@link com.google.gwt.requestfactory.shared.Service} annotations.
  */
-public class DefaultSecurityProvider implements RequestSecurityProvider {
+class DefaultSecurityProvider implements RequestSecurityProvider {
 
   public void checkClass(Class<?> clazz) throws SecurityException {
     Service service = clazz.getAnnotation(Service.class);
-    if (service == null) {
-      throw new SecurityException(
-          "Class " + clazz.getName() + " does not have a @Service annotation.");
+    ServiceName serviceName = clazz.getAnnotation(ServiceName.class);
+    String className;
+    if (service != null) {
+      className = service.value().getName();
+    } else if (serviceName != null) {
+      className = serviceName.value();
+    } else {
+      throw new SecurityException("Class " + clazz.getName()
+          + " does not have a @Service annotation.");
     }
     try {
-      Class.forName(service.value().getCanonicalName());
+      Class.forName(className);
     } catch (ClassNotFoundException e) {
-      throw new SecurityException(
-          "Class " + service.value() + " from @Service annotation on " + clazz
-              + " cannot be loaded.");
+      throw new SecurityException("Class " + className
+          + " from @Service annotation on " + clazz + " cannot be loaded.");
     }
   }
 
diff --git a/user/src/com/google/gwt/requestfactory/server/JsonRequestProcessor.java b/user/src/com/google/gwt/requestfactory/server/JsonRequestProcessor.java
index 5257e62..d067044 100644
--- a/user/src/com/google/gwt/requestfactory/server/JsonRequestProcessor.java
+++ b/user/src/com/google/gwt/requestfactory/server/JsonRequestProcessor.java
@@ -18,6 +18,7 @@
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.EntityProxyId;
 import com.google.gwt.requestfactory.shared.ProxyFor;
+import com.google.gwt.requestfactory.shared.ProxyForName;
 import com.google.gwt.requestfactory.shared.ServerFailure;
 import com.google.gwt.requestfactory.shared.WriteOperation;
 import com.google.gwt.requestfactory.shared.impl.CollectionProperty;
@@ -59,7 +60,7 @@
 /**
  * An implementation of RequestProcessor for JSON encoded payloads.
  */
-public class JsonRequestProcessor implements RequestProcessor<String> {
+class JsonRequestProcessor implements RequestProcessor<String> {
 
   // TODO should we consume String, InputStream, or JSONObject?
   private class DvsData {
@@ -159,7 +160,12 @@
 
   private static final Logger log = Logger.getLogger(JsonRequestProcessor.class.getName());
 
-  // Decodes a string encoded as web-safe base64
+  /**
+   * Decodes a String encoded as web-safe base64.
+   * 
+   * @param encoded the encoded String
+   * @return a decoded String
+   */
   public static String base64Decode(String encoded) {
     byte[] decodedBytes;
     try {
@@ -171,7 +177,12 @@
     return new String(decodedBytes);
   }
 
-  // Encodes a string with web-safe base64
+  /**
+   * Encodes a String as web-safe base64.
+   * 
+   * @param decoded the decoded String
+   * @return an encoded String
+   */
   public static String base64Encode(String decoded) {
     byte[] decodedBytes = decoded.getBytes();
     return Base64Utils.toBase64(decodedBytes);
@@ -218,7 +229,7 @@
 
   private Map<EntityKey, EntityData> afterDvsDataMap = new HashMap<EntityKey, EntityData>();
 
-  @SuppressWarnings(value = {"unchecked", "rawtypes"})
+  // TODO - document
   public Collection<Property<?>> allProperties(
       Class<? extends EntityProxy> clazz) throws IllegalArgumentException {
     return getPropertiesFromRecordProxyType(clazz).values();
@@ -344,8 +355,9 @@
        * 2. Merge the following and the object resolution code in getEntityKey.
        * 3. Update the involvedKeys set.
        */
-      ProxyFor service = parameterType.getAnnotation(ProxyFor.class);
-      if (service != null) {
+      ProxyFor proxyFor = parameterType.getAnnotation(ProxyFor.class);
+      ProxyForName proxyForName = parameterType.getAnnotation(ProxyForName.class);
+      if (proxyFor != null || proxyForName != null) {
         EntityKey entityKey = getEntityKey(parameterValue.toString());
 
         DvsData dvsData = dvsDataMap.get(entityKey);
@@ -361,8 +373,9 @@
     }
     if (EntityProxyId.class.isAssignableFrom(parameterType)) {
       EntityKey entityKey = getEntityKey(parameterValue.toString());
-      ProxyFor service = entityKey.proxyType.getAnnotation(ProxyFor.class);
-      if (service == null) {
+      ProxyFor proxyFor = entityKey.proxyType.getAnnotation(ProxyFor.class);
+      ProxyForName proxyForName = entityKey.proxyType.getAnnotation(ProxyForName.class);
+      if (proxyFor == null && proxyForName == null) {
         throw new IllegalArgumentException("Unknown service, unable to decode "
             + parameterValue);
       }
@@ -375,6 +388,9 @@
 
   /*
    * Encode a property value to be sent across the wire.
+   * 
+   * @param value a value Object
+   * @return an encoded value Object
    */
   public Object encodePropertyValue(Object value) {
     if (value == null) {
@@ -568,6 +584,16 @@
     if (dtoAnn != null) {
       return (Class<Object>) dtoAnn.value();
     }
+    ProxyForName name = record.getAnnotation(ProxyForName.class);
+    if (name != null) {
+      try {
+        return (Class<Object>) Class.forName(name.value(), false,
+            Thread.currentThread().getContextClassLoader());
+      } catch (ClassNotFoundException e) {
+        throw new IllegalArgumentException("Could not find ProxyForName class",
+            e);
+      }
+    }
     throw new IllegalArgumentException("Proxy class " + record.getName()
         + " missing ProxyFor annotation");
   }
@@ -710,7 +736,6 @@
   /**
    * Returns the property fields (name => type) for a record.
    */
-  @SuppressWarnings("unchecked")
   public Map<String, Property<?>> getPropertiesFromRecordProxyType(
       Class<? extends EntityProxy> record) throws SecurityException {
     if (!EntityProxy.class.isAssignableFrom(record)) {
@@ -722,7 +747,7 @@
     for (Method method : methods) {
       String methodName = method.getName();
       String propertyName = null;
-      Property newProperty = null;
+      Property<?> newProperty = null;
       if (methodName.startsWith("get")) {
         propertyName = Introspector.decapitalize(methodName.substring(3));
         if (propertyName.length() == 0) {
@@ -743,7 +768,7 @@
       if (newProperty == null) {
         continue;
       }
-      Property existing = properties.put(propertyName, newProperty);
+      Property<?> existing = properties.put(propertyName, newProperty);
       if (existing != null && !existing.equals(newProperty)) {
         throw new IllegalStateException(String.format(
             "In %s, mismatched getter and setter types for property %s, "
@@ -754,8 +779,8 @@
     return properties;
   }
 
-  @SuppressWarnings("unchecked")
-  public Property getPropertyFromGenericType(String propertyName, Type type) {
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public Property<?> getPropertyFromGenericType(String propertyName, Type type) {
     if (type instanceof ParameterizedType) {
       ParameterizedType pType = (ParameterizedType) type;
       Class<?> rawType = (Class<Object>) pType.getRawType();
@@ -765,7 +790,7 @@
           Type leafType = typeArgs[0];
           if (leafType instanceof Class) {
             return new CollectionProperty(propertyName, rawType,
-                (Class) leafType);
+                (Class<?>) leafType);
           }
         }
       }
@@ -830,6 +855,21 @@
 
     operation = getOperation(operationName);
     Class<?> domainClass = Class.forName(operation.getDomainClassName());
+
+    /*
+     * The use of JRP's classloader mirrors the use of Class.forName elsewhere.
+     * It's wrong, but it's consistently wrong.
+     */
+    RequestFactoryInterfaceValidator validator = new RequestFactoryInterfaceValidator(
+        log, new RequestFactoryInterfaceValidator.ClassLoaderLoader(
+            JsonRequestProcessor.class.getClassLoader()));
+    validator.validateRequestContext(operationName.substring(0,
+        operationName.indexOf("::")));
+    if (validator.isPoisoned()) {
+      log.severe("Unable to validate RequestContext");
+      throw new RuntimeException();
+    }
+
     Method domainMethod = domainClass.getMethod(
         operation.getDomainMethod().getName(), operation.getParameterTypes());
     if (Modifier.isStatic(domainMethod.getModifiers()) == operation.isInstance()) {
@@ -1210,9 +1250,8 @@
     Object newId = getRawPropertyValueFromDatastore(entityInstance,
         Constants.ENTITY_ID_PROPERTY);
     if (newId == null) {
-      log.warning("Record with futureId " + originalEntityKey.encodedId
-          + " not persisted");
-      return null; // no changeRecord for this CREATE.
+      // no changeRecord for this CREATE.
+      return null; 
     }
 
     newId = encodeId(newId);
@@ -1562,6 +1601,14 @@
           if (pFor != null) {
             fieldType = pFor.value();
           }
+          ProxyForName pFN = fieldType.getAnnotation(ProxyForName.class);
+          if (pFN != null) {
+            try {
+              fieldType = Class.forName(pFN.value(), false,
+                  Thread.currentThread().getContextClassLoader());
+            } catch (ClassNotFoundException ignored) {
+            }
+          }
           // TODO: remove override declared method return type with field type
           if (!fieldType.equals(field.getType())) {
             fieldType = field.getType();
diff --git a/user/src/com/google/gwt/requestfactory/server/OperationRegistry.java b/user/src/com/google/gwt/requestfactory/server/OperationRegistry.java
index c769ee0..0b82f15 100644
--- a/user/src/com/google/gwt/requestfactory/server/OperationRegistry.java
+++ b/user/src/com/google/gwt/requestfactory/server/OperationRegistry.java
@@ -18,7 +18,7 @@
 /**
  * Maps operation name to {RequestDefinition}.
  */
-public interface OperationRegistry {
+interface OperationRegistry {
 
   RequestDefinition getOperation(String operationName);
 
diff --git a/user/src/com/google/gwt/requestfactory/server/ReflectionBasedOperationRegistry.java b/user/src/com/google/gwt/requestfactory/server/ReflectionBasedOperationRegistry.java
index b2c89bf..0c81170 100644
--- a/user/src/com/google/gwt/requestfactory/server/ReflectionBasedOperationRegistry.java
+++ b/user/src/com/google/gwt/requestfactory/server/ReflectionBasedOperationRegistry.java
@@ -1,12 +1,12 @@
 /*
  * Copyright 2010 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
@@ -18,8 +18,10 @@
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.InstanceRequest;
 import com.google.gwt.requestfactory.shared.ProxyFor;
+import com.google.gwt.requestfactory.shared.ProxyForName;
 import com.google.gwt.requestfactory.shared.Request;
 import com.google.gwt.requestfactory.shared.Service;
+import com.google.gwt.requestfactory.shared.ServiceName;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -30,13 +32,12 @@
 
 /**
  * OperationRegistry which uses the operation name as a convention for
- * reflection to a method on a class, and returns an appropriate {@link
- * com.google.gwt.requestfactory.server.RequestDefinition}.
+ * reflection to a method on a class, and returns an appropriate
+ * {@link com.google.gwt.requestfactory.server.RequestDefinition}.
  */
-public class ReflectionBasedOperationRegistry implements OperationRegistry {
+class ReflectionBasedOperationRegistry implements OperationRegistry {
 
-  class ReflectiveRequestDefinition
-      implements RequestDefinition {
+  class ReflectiveRequestDefinition implements RequestDefinition {
 
     private Class<?> requestClass;
 
@@ -49,7 +50,8 @@
     private boolean isInstance;
 
     public ReflectiveRequestDefinition(Class<?> requestClass,
-        Method requestMethod, Class<?> domainClass, Method domainMethod, boolean isInstance) {
+        Method requestMethod, Class<?> domainClass, Method domainMethod,
+        boolean isInstance) {
       this.requestClass = requestClass;
       this.requestMethod = requestMethod;
       this.domainClass = domainClass;
@@ -94,20 +96,29 @@
       Class<?> requestReturnType = getReturnTypeFromParameter(requestMethod,
           requestMethod.getGenericReturnType());
       if (EntityProxy.class.isAssignableFrom(requestReturnType)) {
-        ProxyFor annotation =
-            requestReturnType.getAnnotation(ProxyFor.class);
+        ProxyFor annotation = requestReturnType.getAnnotation(ProxyFor.class);
+        ProxyForName nameAnnotation = requestReturnType.getAnnotation(ProxyForName.class);
+
+        Class<?> dtoClass = null;
         if (annotation != null) {
-          Class<?> dtoClass = annotation.value();
-          if (!dtoClass.equals(domainReturnType)) {
+          dtoClass = annotation.value();
+        } else if (nameAnnotation != null) {
+          try {
+            dtoClass = Class.forName(nameAnnotation.value(), false,
+                Thread.currentThread().getContextClassLoader());
+          } catch (ClassNotFoundException e) {
             throw new IllegalArgumentException(
-                "Type mismatch between " + domainMethod + " return type, and "
-                    + requestReturnType + "'s ProxyFor annotation "
-                    + dtoClass);
+                "Unknown type specified in ProxyForName annotation", e);
           }
         } else {
           throw new IllegalArgumentException(
               "Missing ProxyFor annotation on proxy type " + requestReturnType);
         }
+        if (!dtoClass.equals(domainReturnType)) {
+          throw new IllegalArgumentException("Type mismatch between "
+              + domainMethod + " return type, and " + requestReturnType
+              + "'s ProxyFor annotation " + dtoClass);
+        }
         return requestReturnType;
       }
       // primitive ?
@@ -172,7 +183,7 @@
       } else {
         return null;
       }
-      
+
       if (toExamine instanceof ParameterizedType) {
         // if type is for example, RequestObject<List<T>> we return T
         return getTypeArgument((ParameterizedType) toExamine);
@@ -186,13 +197,18 @@
 
   private RequestSecurityProvider securityProvider;
 
+  /**
+   * Constructs a {@link ReflectionBasedOperationRegistry} instance with a given
+   * {@link RequestSecurityProvider}.
+   * 
+   * @param securityProvider a {@link RequestSecurityProvider} instance.
+   */
   public ReflectionBasedOperationRegistry(
       RequestSecurityProvider securityProvider) {
     this.securityProvider = securityProvider;
   }
 
   /**
-
    * Turns an operation in the form of package.requestClass::method into a
    * RequestDefinition via reflection.
    */
@@ -208,25 +224,34 @@
           this.getClass().getClassLoader());
       securityProvider.checkClass(requestClass);
       Service domainClassAnnotation = requestClass.getAnnotation(Service.class);
+      ServiceName domainClassNameAnnotation = requestClass.getAnnotation(ServiceName.class);
+      Class<?> domainClass;
       if (domainClassAnnotation != null) {
-        Class<?> domainClass = domainClassAnnotation.value();
-        Method requestMethod = findMethod(requestClass, domainMethodName);
-        Method domainMethod = findMethod(domainClass, domainMethodName);
-        if (requestMethod != null && domainMethod != null) {
-          boolean isInstance = InstanceRequest.class.isAssignableFrom(requestMethod.getReturnType());
-          if (isInstance == Modifier.isStatic(domainMethod.getModifiers())) {
-            throw new IllegalArgumentException("domain method " + domainMethod
-                + " and interface method " + requestMethod
-                + " don't match wrt instance/static");
-          }
-          return new ReflectiveRequestDefinition(requestClass, requestMethod,
-              domainClass, domainMethod, isInstance);
-        }
+        domainClass = domainClassAnnotation.value();
+      } else if (domainClassNameAnnotation != null) {
+        domainClass = Class.forName(domainClassNameAnnotation.value(), false,
+            Thread.currentThread().getContextClassLoader());
+      } else {
+        return null;
       }
+
+      Method requestMethod = findMethod(requestClass, domainMethodName);
+      Method domainMethod = findMethod(domainClass, domainMethodName);
+      if (requestMethod != null && domainMethod != null) {
+        boolean isInstance = InstanceRequest.class.isAssignableFrom(requestMethod.getReturnType());
+        if (isInstance == Modifier.isStatic(domainMethod.getModifiers())) {
+          throw new IllegalArgumentException("domain method " + domainMethod
+              + " and interface method " + requestMethod
+              + " don't match wrt instance/static");
+        }
+        return new ReflectiveRequestDefinition(requestClass, requestMethod,
+            domainClass, domainMethod, isInstance);
+      }
+
       return null;
     } catch (ClassNotFoundException e) {
-      throw new SecurityException(
-          "Access to non-existent class " + reqClassName);
+      throw new SecurityException("Access to non-existent class "
+          + reqClassName);
     }
   }
 
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestDefinition.java b/user/src/com/google/gwt/requestfactory/server/RequestDefinition.java
index 1e0db57..48ed9be 100644
--- a/user/src/com/google/gwt/requestfactory/server/RequestDefinition.java
+++ b/user/src/com/google/gwt/requestfactory/server/RequestDefinition.java
@@ -22,7 +22,7 @@
  * Implemented by enums that define the mapping between request objects and
  * service methods.
  */
-public interface RequestDefinition {
+interface RequestDefinition {
   /**
    * Returns the name of the (domain) class that contains the method to be
    * invoked on the server.
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidator.java b/user/src/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidator.java
new file mode 100644
index 0000000..4903bea
--- /dev/null
+++ b/user/src/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidator.java
@@ -0,0 +1,1070 @@
+/*
+ * Copyright 2010 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.requestfactory.server;
+
+import com.google.gwt.dev.asm.AnnotationVisitor;
+import com.google.gwt.dev.asm.ClassReader;
+import com.google.gwt.dev.asm.ClassVisitor;
+import com.google.gwt.dev.asm.MethodVisitor;
+import com.google.gwt.dev.asm.Opcodes;
+import com.google.gwt.dev.asm.Type;
+import com.google.gwt.dev.asm.commons.EmptyVisitor;
+import com.google.gwt.dev.asm.commons.Method;
+import com.google.gwt.dev.asm.signature.SignatureReader;
+import com.google.gwt.dev.asm.signature.SignatureVisitor;
+import com.google.gwt.dev.util.Name;
+import com.google.gwt.dev.util.Name.BinaryName;
+import com.google.gwt.dev.util.Name.SourceOrBinaryName;
+import com.google.gwt.requestfactory.client.impl.FindRequest;
+import com.google.gwt.requestfactory.shared.EntityProxy;
+import com.google.gwt.requestfactory.shared.InstanceRequest;
+import com.google.gwt.requestfactory.shared.ProxyFor;
+import com.google.gwt.requestfactory.shared.ProxyForName;
+import com.google.gwt.requestfactory.shared.Request;
+import com.google.gwt.requestfactory.shared.RequestContext;
+import com.google.gwt.requestfactory.shared.RequestFactory;
+import com.google.gwt.requestfactory.shared.Service;
+import com.google.gwt.requestfactory.shared.ServiceName;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Encapsulates validation logic to determine if a {@link RequestFactory}
+ * interface, its {@link RequestContext}, and associated {@link EntityProxy}
+ * interfaces match their domain counterparts. This implementation examines the
+ * classfiles directly in order to avoid the need to load the types into the
+ * JVM.
+ */
+public class RequestFactoryInterfaceValidator {
+  /**
+   * An implementation of {@link Loader} that uses a {@link ClassLoader} to
+   * retrieve the class files.
+   */
+  public static class ClassLoaderLoader implements Loader {
+    private final ClassLoader loader;
+
+    public ClassLoaderLoader(ClassLoader loader) {
+      this.loader = loader;
+    }
+
+    public boolean exists(String resource) {
+      return loader.getResource(resource) != null;
+    }
+
+    public InputStream getResourceAsStream(String resource) {
+      return loader.getResourceAsStream(resource);
+    }
+  }
+
+  /**
+   * Abstracts the mechanism by which class files are loaded.
+   * 
+   * @see ClassLoaderLoader
+   */
+  public interface Loader {
+    /**
+     * Returns true if the specified resource can be loaded.
+     */
+    boolean exists(String resource);
+
+    /**
+     * Returns an InputStream to access the specified resource, or
+     * <code>null</code> if no such resource exists.
+     */
+    InputStream getResourceAsStream(String resource);
+  }
+
+  /**
+   * Used internally as a placeholder for types that cannot be mapped to a
+   * domain object.
+   */
+  interface MissingDomainType {
+  }
+
+  /**
+   * Collects the ProxyFor or Service annotation from an EntityProxy or
+   * RequestContext type.
+   */
+  private class DomainMapper extends EmptyVisitor {
+    private final ErrorContext logger;
+    private String domainInternalName;
+
+    public DomainMapper(ErrorContext logger) {
+      this.logger = logger;
+      logger.spam("Finding domain mapping annotation");
+    }
+
+    public String getDomainInternalName() {
+      return domainInternalName;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+        String superName, String[] interfaces) {
+      if ((access & Opcodes.ACC_INTERFACE) == 0) {
+        logger.poison("Type must be an interface");
+      }
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+      boolean foundProxy = desc.equals(Type.getDescriptor(ProxyFor.class));
+      boolean foundProxyName = desc.equals(Type.getDescriptor(ProxyForName.class));
+      boolean foundService = desc.equals(Type.getDescriptor(Service.class));
+      boolean foundServiceName = desc.equals(Type.getDescriptor(ServiceName.class));
+
+      if (foundProxy || foundService) {
+        return new EmptyVisitor() {
+
+          @Override
+          public void visit(String name, Object value) {
+            domainInternalName = ((Type) value).getInternalName();
+          }
+
+        };
+      }
+
+      if (foundProxyName || foundServiceName) {
+        return new EmptyVisitor() {
+          @Override
+          public void visit(String name, Object value) {
+            String sourceName = (String) value;
+
+            /*
+             * The input is a source name, so we need to convert it to an
+             * internal name. We'll do this by substituting dollar signs for the
+             * last slash in the name until there are no more slashes.
+             */
+            StringBuffer desc = new StringBuffer(sourceName.replace('.', '/'));
+            while (!loader.exists(desc.toString() + ".class")) {
+              logger.spam("Did not find " + desc.toString());
+              int idx = desc.lastIndexOf("/");
+              if (idx == -1) {
+                return;
+              }
+              desc.setCharAt(idx, '$');
+            }
+
+            domainInternalName = desc.toString();
+            logger.spam(domainInternalName);
+          }
+        };
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Improves error messages by providing context for the user.
+   */
+  private class ErrorContext {
+    private final Logger logger;
+    private final ErrorContext parent;
+    private Type currentType;
+    private Method currentMethod;
+
+    public ErrorContext(Logger logger) {
+      this.logger = logger;
+      this.parent = null;
+    }
+
+    private ErrorContext(ErrorContext parent) {
+      this.logger = parent.logger;
+      this.parent = parent;
+    }
+
+    public void poison(String msg, Object... args) {
+      logger.logp(Level.SEVERE, currentType(), currentMethod(),
+          String.format(msg, args));
+      poisoned = true;
+    }
+
+    public void poison(String msg, Throwable t) {
+      logger.logp(Level.SEVERE, currentType(), currentMethod(), msg, t);
+      poisoned = true;
+    }
+
+    public ErrorContext setMethod(Method method) {
+      ErrorContext toReturn = new ErrorContext(this);
+      toReturn.currentMethod = method;
+      return toReturn;
+    }
+
+    public ErrorContext setType(Type type) {
+      ErrorContext toReturn = new ErrorContext(this);
+      toReturn.currentType = type;
+      return toReturn;
+    }
+
+    public void spam(String msg, Object... args) {
+      logger.logp(Level.FINEST, currentType(), currentMethod(),
+          String.format(msg, args));
+    }
+
+    private String currentMethod() {
+      if (currentMethod != null) {
+        return print(currentMethod);
+      }
+      if (parent != null) {
+        return parent.currentMethod();
+      }
+      return null;
+    }
+
+    private String currentType() {
+      if (currentType != null) {
+        return print(currentType);
+      }
+      if (parent != null) {
+        return parent.currentType();
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Collects information about domain objects. This visitor is intended to be
+   * iteratively applied to collect all methods in a type hierarchy.
+   */
+  private class MethodsInHierarchyCollector extends EmptyVisitor {
+    private final ErrorContext logger;
+    private Set<RFMethod> methods = new LinkedHashSet<RFMethod>();
+    private Set<String> seen = new HashSet<String>();
+
+    private MethodsInHierarchyCollector(ErrorContext logger) {
+      this.logger = logger;
+    }
+
+    public Set<RFMethod> exec(String internalName) {
+      RequestFactoryInterfaceValidator.this.visit(logger, internalName, this);
+      return methods;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+        String superName, String[] interfaces) {
+      if (!seen.add(name)) {
+        return;
+      }
+      if (!"java/lang/Object".equals(superName)) {
+        RequestFactoryInterfaceValidator.this.visit(logger, superName, this);
+      }
+      if (interfaces != null) {
+        for (String intf : interfaces) {
+          RequestFactoryInterfaceValidator.this.visit(logger, intf, this);
+        }
+      }
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc,
+        String signature, String[] exceptions) {
+      RFMethod method = new RFMethod(name, desc);
+      method.setDeclaredStatic((access & Opcodes.ACC_STATIC) != 0);
+      method.setDeclaredSignature(signature);
+      methods.add(method);
+      return null;
+    }
+  }
+
+  private static class RFMethod extends Method {
+    private boolean isDeclaredStatic;
+    private String signature;
+
+    public RFMethod(String name, String desc) {
+      super(name, desc);
+    }
+
+    public String getSignature() {
+      return signature;
+    }
+
+    public boolean isDeclaredStatic() {
+      return isDeclaredStatic;
+    }
+
+    public void setDeclaredSignature(String signature) {
+      this.signature = signature;
+    }
+
+    public void setDeclaredStatic(boolean value) {
+      isDeclaredStatic = value;
+    }
+
+    @Override
+    public String toString() {
+      return (isDeclaredStatic ? "static " : "") + super.toString();
+    }
+  }
+
+  private class SupertypeCollector extends EmptyVisitor {
+    private final ErrorContext logger;
+    private final Set<String> seen = new HashSet<String>();
+    private final List<Type> supertypes = new ArrayList<Type>();
+
+    public SupertypeCollector(ErrorContext logger) {
+      this.logger = logger;
+    }
+
+    public List<Type> exec(Type type) {
+      RequestFactoryInterfaceValidator.this.visit(logger,
+          type.getInternalName(), this);
+      return supertypes;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+        String superName, String[] interfaces) {
+      if (!seen.add(name)) {
+        return;
+      }
+      supertypes.add(Type.getObjectType(name));
+      if (!"java/lang/Object".equals(name)) {
+        RequestFactoryInterfaceValidator.this.visit(logger, superName, this);
+      }
+      if (interfaces != null) {
+        for (String intf : interfaces) {
+          RequestFactoryInterfaceValidator.this.visit(logger, intf, this);
+        }
+      }
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  static final Set<Class<?>> VALUE_TYPES = Collections.unmodifiableSet(new HashSet<Class<?>>(
+      Arrays.asList(Boolean.class, Character.class, Class.class, Date.class,
+          Enum.class, Number.class, String.class, Void.class)));
+
+  public static void main(String[] args) {
+    if (args.length == 0) {
+      System.err.println("Usage: java -cp gwt-servlet.jar:your-code.jar "
+          + RequestFactoryInterfaceValidator.class.getCanonicalName()
+          + " com.example.MyRequestFactory");
+      System.exit(1);
+    }
+    RequestFactoryInterfaceValidator validator = new RequestFactoryInterfaceValidator(
+        Logger.getLogger(RequestFactoryInterfaceValidator.class.getName()),
+        new ClassLoaderLoader(Thread.currentThread().getContextClassLoader()));
+    validator.validateRequestFactory(args[0]);
+    System.exit(validator.isPoisoned() ? 1 : 0);
+  }
+
+  private static String print(Method method) {
+    StringBuilder sb = new StringBuilder();
+    sb.append(print(method.getReturnType())).append(" ").append(
+        method.getName()).append("(");
+    for (Type t : method.getArgumentTypes()) {
+      sb.append(print(t)).append(" ");
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  private static String print(Type type) {
+    return SourceOrBinaryName.toSourceName(type.getClassName());
+  }
+
+  /**
+   * Maps client types (e.g. FooProxy) to server domain types (e.g. Foo).
+   */
+  private final Map<Type, Type> clientToDomainType = new HashMap<Type, Type>();
+  /**
+   * The type {@link EntityProxy}.
+   */
+  private final Type entityProxyIntf = Type.getType(EntityProxy.class);
+  /**
+   * A placeholder type for client types that could not be resolved to a domain
+   * type.
+   */
+  private final Type errorType = Type.getType(MissingDomainType.class);
+  /**
+   * The type {@link InstanceRequest}.
+   */
+  private final Type instanceRequestIntf = Type.getType(InstanceRequest.class);
+  private final Loader loader;
+  /**
+   * A cache of all methods defined in a type hierarchy.
+   */
+  private final Map<Type, Set<RFMethod>> methodsInHierarchy = new HashMap<Type, Set<RFMethod>>();
+  private final ErrorContext parentLogger;
+  private boolean poisoned;
+  /**
+   * The type {@link Request}.
+   */
+  private final Type requestIntf = Type.getType(Request.class);
+  /**
+   * The type {@link RequestContext}.
+   */
+  private final Type requestContextIntf = Type.getType(RequestContext.class);
+  /**
+   * A map of a type to all types that it could be assigned to.
+   */
+  private final Map<Type, List<Type>> supertypes = new HashMap<Type, List<Type>>();
+  /**
+   * A set to prevent re-validation of a type.
+   */
+  private final Set<String> validatedTypes = new HashSet<String>();
+
+  /**
+   * Contains vaue types (e.g. Integer).
+   */
+  private final Set<Type> valueTypes = new HashSet<Type>();
+
+  public RequestFactoryInterfaceValidator(Logger logger, Loader loader) {
+    this.parentLogger = new ErrorContext(logger);
+    this.loader = loader;
+    for (Class<?> clazz : VALUE_TYPES) {
+      valueTypes.add(Type.getType(clazz));
+    }
+  }
+
+  /**
+   * Returns true if validation failed.
+   */
+  public boolean isPoisoned() {
+    return poisoned;
+  }
+
+  /**
+   * This method checks an EntityProxy interface against its peer domain object
+   * to determine if the server code would be able to process a request using
+   * the methods defined in the EntityProxy interface. It does not perform any
+   * checks as to whether or not the EntityProxy could actually be generated by
+   * the Generator.
+   * <p>
+   * This method may be called repeatedly on a single instance of the validator.
+   * Doing so will amortize type calculation costs.
+   * <p>
+   * Checks implemented:
+   * <ul>
+   * <li> <code>binaryName</code> implements EntityProxy</li>
+   * <li><code>binaryName</code> has a {@link ProxyFor} or {@link ProxyForName}
+   * annotation</li>
+   * <li>The domain object has getId() and getVersion() methods</li>
+   * <li>All property methods in the EntityProxy can be mapped onto an
+   * equivalent domain method</li>
+   * <li>All referenced EntityProxy types are valid</li>
+   * </ul>
+   * 
+   * @param binaryName the binary name (e.g. {@link Class#getName()}) of the
+   *          EntityProxy subtype
+   */
+  public void validateEntityProxy(String binaryName) {
+    if (!Name.isBinaryName(binaryName)) {
+      parentLogger.poison("%s is not a binary name", binaryName);
+      return;
+    }
+
+    // Don't revalidate the same type
+    if (!validatedTypes.add(binaryName)) {
+      return;
+    }
+
+    Type proxyType = Type.getObjectType(BinaryName.toInternalName(binaryName));
+    ErrorContext logger = parentLogger.setType(proxyType);
+
+    // Quick sanity check for calling code
+    if (!isAssignable(logger, entityProxyIntf, proxyType)) {
+      parentLogger.poison("%s is not a %s", print(proxyType),
+          EntityProxy.class.getSimpleName());
+      return;
+    }
+
+    // Find the domain type
+    Type domainType = getDomainType(logger, proxyType);
+    if (domainType == errorType) {
+      logger.poison(
+          "The type %s must be annotated with a @%s or @%s annotation",
+          BinaryName.toSourceName(binaryName), ProxyFor.class.getSimpleName(),
+          ProxyForName.class.getSimpleName());
+      return;
+    }
+
+    // Check for getId() and getVersion() in domain
+    checkIdAndVersion(logger, domainType);
+
+    // Collect all methods in the client proxy type
+    Set<RFMethod> clientPropertyMethods = getMethodsInHierarchy(logger,
+        proxyType);
+
+    // Find the equivalent domain getter/setter method
+    for (RFMethod clientPropertyMethod : clientPropertyMethods) {
+      // Ignore stableId(). Can't use descriptor due to overrides
+      if ("stableId".equals(clientPropertyMethod.getName())
+          && clientPropertyMethod.getArgumentTypes().length == 0) {
+        continue;
+      }
+      checkPropertyMethod(logger, clientPropertyMethod, domainType);
+      maybeCheckReferredProxies(logger, clientPropertyMethod);
+    }
+  }
+
+  /**
+   * This method checks a RequestContext interface against its peer domain
+   * domain object to determine if the server code would be able to process a
+   * request using the the methods defined in the RequestContext interface. It
+   * does not perform any checks as to whether or not the RequestContext could
+   * actually be generated by the Generator.
+   * <p>
+   * This method may be called repeatedly on a single instance of the validator.
+   * Doing so will amortize type calculation costs.
+   * <p>
+   * Checks implemented:
+   * <ul>
+   * <li> <code>binaryName</code> implements RequestContext</li>
+   * <li><code>binaryName</code> has a {@link Service} or {@link ServiceName}
+   * annotation</li>
+   * <li>All service methods in the RequestContext can be mapped onto an
+   * equivalent domain method</li>
+   * <li>All referenced EntityProxy types are valid</li>
+   * </ul>
+   * 
+   * @param binaryName the binary name (e.g. {@link Class#getName()}) of the
+   *          RequestContext subtype
+   * @see #validateEntityProxy(String)
+   */
+  public void validateRequestContext(String binaryName) {
+    if (!Name.isBinaryName(binaryName)) {
+      parentLogger.poison("%s is not a binary name", binaryName);
+      return;
+    }
+
+    // Don't revalidate the same type
+    if (!validatedTypes.add(binaryName)) {
+      return;
+    }
+
+    if (FindRequest.class.getName().equals(binaryName)) {
+      // Ignore FindRequest, it's a huge hack
+      return;
+    }
+
+    Type requestContextType = Type.getObjectType(BinaryName.toInternalName(binaryName));
+    final ErrorContext logger = parentLogger.setType(requestContextType);
+
+    // Quick sanity check for calling code
+    if (!isAssignable(logger, requestContextIntf, requestContextType)) {
+      logger.poison("%s is not a %s", print(requestContextType),
+          RequestContext.class.getSimpleName());
+      return;
+    }
+
+    Type domainServiceType = getDomainType(logger, requestContextType);
+    if (domainServiceType == errorType) {
+      logger.poison(
+          "The type %s must be annotated with a @%s or @%s annotation",
+          BinaryName.toSourceName(binaryName), Service.class.getSimpleName(),
+          ServiceName.class.getSimpleName());
+      return;
+    }
+
+    for (RFMethod method : getMethodsInHierarchy(logger, requestContextType)) {
+      // Ignore methods in RequestContext itself
+      if (findCompatibleMethod(logger, requestContextIntf, method, false, true) != null) {
+        continue;
+      }
+
+      // Check the client method against the domain
+      checkClientMethodInDomain(logger, method, domainServiceType);
+      maybeCheckReferredProxies(logger, method);
+    }
+  }
+
+  /**
+   * This method checks a RequestFactory interface.
+   * <p>
+   * This method may be called repeatedly on a single instance of the validator.
+   * Doing so will amortize type calculation costs. It does not perform any
+   * checks as to whether or not the RequestContext could actually be generated
+   * by the Generator.
+   * <p>
+   * Checks implemented:
+   * <ul>
+   * <li> <code>binaryName</code> implements RequestFactory</li>
+   * <li>All referenced RequestContext types are valid</li>
+   * </ul>
+   * 
+   * @param binaryName the binary name (e.g. {@link Class#getName()}) of the
+   *          RequestContext subtype
+   * @see #validateRequestContext(String)
+   */
+  public void validateRequestFactory(String binaryName) {
+    if (!Name.isBinaryName(binaryName)) {
+      parentLogger.poison("%s is not a binary name", binaryName);
+      return;
+    }
+
+    // Don't revalidate the same type
+    if (!validatedTypes.add(binaryName)) {
+      return;
+    }
+
+    Type requestFactoryType = Type.getObjectType(BinaryName.toInternalName(binaryName));
+    ErrorContext logger = parentLogger.setType(requestFactoryType);
+
+    // Quick sanity check for calling code
+    if (!isAssignable(logger, Type.getType(RequestFactory.class),
+        requestFactoryType)) {
+      logger.poison("%s is not a %s", print(requestFactoryType),
+          RequestFactory.class.getSimpleName());
+      return;
+    }
+
+    // Validate each RequestContext method in the RF
+    for (Method contextMethod : getMethodsInHierarchy(logger,
+        requestFactoryType)) {
+      Type returnType = contextMethod.getReturnType();
+      if (isAssignable(logger, requestContextIntf, returnType)) {
+        validateRequestContext(returnType.getClassName());
+      }
+    }
+  }
+
+  /**
+   * Check that a given method RequestContext method declaration can be mapped
+   * to the server's domain type.
+   */
+  private void checkClientMethodInDomain(ErrorContext logger, RFMethod method,
+      Type domainServiceType) {
+    logger = logger.setMethod(method);
+
+    // Create a "translated" method declaration to search for
+    // Request<BlahProxy> foo(int a, BarProxy bar) -> Blah foo(int a, Bar bar);
+    Type returnType = getReturnType(logger, method);
+    Method searchFor = createDomainMethod(logger, new Method(method.getName(),
+        returnType, method.getArgumentTypes()));
+
+    RFMethod found = findCompatibleMethod(logger, domainServiceType, searchFor);
+
+    if (found != null) {
+      boolean isInstance = isAssignable(logger, instanceRequestIntf,
+          method.getReturnType());
+      if (isInstance && found.isDeclaredStatic()) {
+        logger.poison("The method %s is declared to return %s, but the"
+            + " service method is static", method.getName(),
+            InstanceRequest.class.getCanonicalName());
+      } else if (!isInstance && !found.isDeclaredStatic) {
+        logger.poison("The method %s is declared to return %s, but the"
+            + " service method is not static", method.getName(),
+            Request.class.getCanonicalName());
+      }
+    }
+  }
+
+  /**
+   * Check that the domain object has <code>getId()</code> and
+   * <code>getVersion</code> methods.
+   */
+  private void checkIdAndVersion(ErrorContext logger, Type domainType) {
+    logger = logger.setType(domainType);
+    Method getIdString = new Method("getId", "()Ljava/lang/String;");
+    Method getIdLong = new Method("getId", "()Ljava/lang/Long;");
+    if (findCompatibleMethod(logger, domainType, getIdString, false, true) == null
+        && findCompatibleMethod(logger, domainType, getIdLong, false, true) == null) {
+      logger.poison("Did not find a getId() method that"
+          + " returns a String or a Long");
+    }
+
+    Method getVersion = new Method("getVersion", "()Ljava/lang/Integer;");
+    if (findCompatibleMethod(logger, domainType, getVersion) == null) {
+      logger.poison("Did not find a getVersion() method"
+          + " that returns an Integer");
+    }
+  }
+
+  /**
+   * Ensure that the given property method on an EntityProxy exists on the
+   * domain object.
+   */
+  private void checkPropertyMethod(ErrorContext logger,
+      Method clientPropertyMethod, Type domainType) {
+    logger = logger.setMethod(clientPropertyMethod);
+
+    findCompatibleMethod(logger, domainType,
+        createDomainMethod(logger, clientPropertyMethod));
+  }
+
+  /**
+   * Convert a method declaration using client types (e.g. FooProxy) to domain
+   * types (e.g. Foo).
+   */
+  private Method createDomainMethod(ErrorContext logger, Method clientMethod) {
+    Type[] args = clientMethod.getArgumentTypes();
+    for (int i = 0, j = args.length; i < j; i++) {
+      args[i] = getDomainType(logger, args[i]);
+    }
+    Type returnType = getDomainType(logger, clientMethod.getReturnType());
+    return new Method(clientMethod.getName(), returnType, args);
+  }
+
+  /**
+   * Finds a compatible method declaration in <code>domainType</code>'s
+   * hierarchy that is assignment-compatible with the given Method.
+   */
+  private RFMethod findCompatibleMethod(final ErrorContext logger,
+      Type domainType, Method searchFor) {
+    return findCompatibleMethod(logger, domainType, searchFor, true, false);
+  }
+
+  /**
+   * Finds a compatible method declaration in <code>domainType</code>'s
+   * hierarchy that is assignment-compatible with the given Method.
+   */
+  private RFMethod findCompatibleMethod(final ErrorContext logger,
+      Type domainType, Method searchFor, boolean mustFind,
+      boolean allowOverloads) {
+    String methodName = searchFor.getName();
+    Type[] clientArgs = searchFor.getArgumentTypes();
+    Type clientReturnType = searchFor.getReturnType();
+    // Pull all methods out of the domain type
+    Map<String, List<RFMethod>> domainLookup = new LinkedHashMap<String, List<RFMethod>>();
+    for (RFMethod method : getMethodsInHierarchy(logger, domainType)) {
+      List<RFMethod> list = domainLookup.get(method.getName());
+      if (list == null) {
+        list = new ArrayList<RFMethod>();
+        domainLookup.put(method.getName(), list);
+      }
+      list.add(method);
+    }
+
+    // Find the matching method in the domain object
+    List<RFMethod> methods = domainLookup.get(methodName);
+    if (methods == null) {
+      if (mustFind) {
+        logger.poison("Could not find any methods named %s in %s", methodName,
+            print(domainType));
+      }
+      return null;
+    }
+    if (methods.size() > 1 && !allowOverloads) {
+      StringBuilder sb = new StringBuilder();
+      sb.append(String.format("Method overloads found in type %s named %s:\n",
+          print(domainType), methodName));
+      for (RFMethod method : methods) {
+        sb.append("  ").append(print(method)).append("\n");
+      }
+      logger.poison(sb.toString());
+      return null;
+    }
+
+    // Check each overloaded name
+    for (RFMethod domainMethod : methods) {
+      // Box any primitive types to simplify compotibility check
+      Type[] domainArgs = domainMethod.getArgumentTypes();
+      for (int i = 0, j = domainArgs.length; i < j; i++) {
+        domainArgs[i] = maybeBoxType(domainArgs[i]);
+      }
+      Type domainReturnType = maybeBoxType(domainMethod.getReturnType());
+
+      /*
+       * Make sure the client args can be passed into the domain args and the
+       * domain return type into the client return type.
+       */
+      if (isAssignable(logger, domainArgs, clientArgs)
+          && isAssignable(logger, clientReturnType, domainReturnType)) {
+
+        logger.spam("Mapped client method " + print(searchFor) + " to "
+            + print(domainMethod));
+        return domainMethod;
+      }
+    }
+    if (mustFind) {
+      StringBuilder sb = new StringBuilder();
+      sb.append(String.format(
+          "Could not find matching method in %s:\nPossible matches:\n",
+          print(domainType)));
+      for (RFMethod domainMethod : methods) {
+        sb.append("  ").append(print(domainMethod)).append("\n");
+      }
+      logger.poison(sb.toString());
+    }
+    return null;
+  }
+
+  /**
+   * This looks like it should be a utility method somewhere else, but I can't
+   * find it.
+   */
+  private Type getBoxedType(Type primitive) {
+    switch (primitive.getSort()) {
+      case Type.BOOLEAN:
+        return Type.getType(Boolean.class);
+      case Type.BYTE:
+        return Type.getType(Byte.class);
+      case Type.CHAR:
+        return Type.getType(Character.class);
+      case Type.DOUBLE:
+        return Type.getType(Double.class);
+      case Type.FLOAT:
+        return Type.getType(Float.class);
+      case Type.INT:
+        return Type.getType(Integer.class);
+      case Type.LONG:
+        return Type.getType(Long.class);
+      case Type.SHORT:
+        return Type.getType(Short.class);
+      case Type.VOID:
+        return Type.getType(Void.class);
+    }
+    throw new RuntimeException(primitive.getDescriptor()
+        + " is not a primitive type");
+  }
+
+  /**
+   * Convert the type used in a client-side EntityProxy or RequestContext
+   * declaration to the equivalent domain type. Value types and supported
+   * collections are a pass-through. EntityProxy types will be resolved to their
+   * domain object type. RequestContext types will be resolved to their service
+   * object.
+   */
+  private Type getDomainType(ErrorContext logger, Type clientType) {
+    Type toReturn = clientToDomainType.get(clientType);
+    if (toReturn != null) {
+      return toReturn;
+    }
+    if (isValueType(logger, clientType) || isCollectionType(logger, clientType)) {
+      toReturn = clientType;
+    } else {
+      logger = logger.setType(clientType);
+      DomainMapper pv = new DomainMapper(logger);
+      visit(logger, clientType.getInternalName(), pv);
+      if (pv.getDomainInternalName() == null) {
+        logger.poison("%s has no mapping to a domain type (e.g. @%s or @%s)",
+            print(clientType), ProxyFor.class.getSimpleName(),
+            Service.class.getSimpleName());
+        toReturn = errorType;
+      } else {
+        toReturn = Type.getObjectType(pv.getDomainInternalName());
+      }
+    }
+    clientToDomainType.put(clientType, toReturn);
+    return toReturn;
+  }
+
+  /**
+   * Collect all of the methods defined within a type hierarchy.
+   */
+  private Set<RFMethod> getMethodsInHierarchy(ErrorContext logger,
+      Type domainType) {
+    Set<RFMethod> toReturn = methodsInHierarchy.get(domainType);
+    if (toReturn == null) {
+      logger = logger.setType(domainType);
+      toReturn = new MethodsInHierarchyCollector(logger).exec(domainType.getInternalName());
+      methodsInHierarchy.put(domainType, Collections.unmodifiableSet(toReturn));
+    }
+    return toReturn;
+  }
+
+  /**
+   * Examines a generic RequestContext method declaration and determines the
+   * expected domain return type. This implementation is limited in that it will
+   * not attempt to resolve type bounds since that would essentially require
+   * implementing TypeOracle. In the case where the type bound cannot be
+   * resolved, this method will return Object's type.
+   */
+  private Type getReturnType(ErrorContext logger, RFMethod method) {
+    logger = logger.setMethod(method);
+    final String[] returnType = {"java/lang/Object"};
+    String signature = method.getSignature();
+
+    final int expectedCount;
+    if (method.getReturnType().equals(instanceRequestIntf)) {
+      expectedCount = 2;
+    } else if (method.getReturnType().equals(requestIntf)) {
+      expectedCount = 1;
+    } else {
+      logger.spam("Punting on " + signature);
+      return Type.getObjectType(returnType[0]);
+    }
+
+    // TODO(bobv): If a class-based TypeOracle is built, use that instead
+    new SignatureReader(signature).accept(new SignatureAdapter() {
+      @Override
+      public SignatureVisitor visitReturnType() {
+        return new SignatureAdapter() {
+          int count;
+
+          @Override
+          public SignatureVisitor visitTypeArgument(char wildcard) {
+            if (++count == expectedCount) {
+              return new SignatureAdapter() {
+                @Override
+                public void visitClassType(String name) {
+                  returnType[0] = name;
+                }
+              };
+            }
+            return super.visitTypeArgument(wildcard);
+          }
+        };
+      }
+    });
+
+    logger.spam("Extracted " + returnType[0]);
+    return Type.getObjectType(returnType[0]);
+  }
+
+  private List<Type> getSupertypes(ErrorContext logger, Type type) {
+    if (type.getSort() != Type.OBJECT) {
+      return Collections.emptyList();
+    }
+    List<Type> toReturn = supertypes.get(type);
+    if (toReturn != null) {
+      return toReturn;
+    }
+    logger = logger.setType(type);
+    toReturn = new SupertypeCollector(logger).exec(type);
+    supertypes.put(type, Collections.unmodifiableList(toReturn));
+    return toReturn;
+  }
+
+  private boolean isAssignable(ErrorContext logger, Type possibleSupertype,
+      Type possibleSubtype) {
+    // Fast-path for same type
+    if (possibleSupertype.equals(possibleSubtype)) {
+      return true;
+    }
+
+    // Box primitive types to make this simple
+    if (possibleSupertype.getSort() != Type.OBJECT) {
+      possibleSupertype = getBoxedType(possibleSupertype);
+    }
+    if (possibleSubtype.getSort() != Type.OBJECT) {
+      possibleSubtype = getBoxedType(possibleSubtype);
+    }
+
+    // Supertype calculation is cached
+    List<Type> allSupertypes = getSupertypes(logger, possibleSubtype);
+    return allSupertypes.contains(possibleSupertype);
+  }
+
+  private boolean isAssignable(ErrorContext logger, Type[] possibleSupertypes,
+      Type[] possibleSubtypes) {
+    // Check the same number of types
+    if (possibleSupertypes.length != possibleSubtypes.length) {
+      return false;
+    }
+    for (int i = 0, j = possibleSupertypes.length; i < j; i++) {
+      if (!isAssignable(logger, possibleSupertypes[i], possibleSubtypes[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean isCollectionType(ErrorContext logger, Type type) {
+    return "java/util/List".equals(type.getInternalName())
+        || "java/util/Set".equals(type.getInternalName());
+  }
+
+  private boolean isValueType(ErrorContext logger, Type type) {
+    if (type.getSort() != Type.OBJECT) {
+      return true;
+    }
+    if (valueTypes.contains(type)) {
+      return true;
+    }
+    logger = logger.setType(type);
+    List<Type> types = getSupertypes(logger, type);
+    for (Type t : types) {
+      if (valueTypes.contains(t)) {
+        valueTypes.add(type);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private Type maybeBoxType(Type maybePrimitive) {
+    if (maybePrimitive.getSort() == Type.OBJECT) {
+      return maybePrimitive;
+    }
+    return getBoxedType(maybePrimitive);
+  }
+
+  /**
+   * Examine an array of Types and call {@link #validateEntityProxy(String)} if
+   * the type is an EntityProxy.
+   */
+  private void maybeCheckEntityProxyType(ErrorContext logger, Type... types) {
+    for (Type type : types) {
+      if (isAssignable(logger, entityProxyIntf, type)) {
+        validateEntityProxy(type.getClassName());
+      }
+    }
+  }
+
+  /**
+   * Examine the arguments ond return value of a method and check any
+   * EntityProxies referred.
+   */
+  private void maybeCheckReferredProxies(ErrorContext logger, RFMethod method) {
+    Type[] argTypes = method.getArgumentTypes();
+    Type returnType = getReturnType(logger, method);
+
+    // Check EntityProxy args ond return types against the domain
+    maybeCheckEntityProxyType(logger, argTypes);
+    maybeCheckEntityProxyType(logger, returnType);
+  }
+
+  /**
+   * Load the classfile for the given binary name and apply the provided
+   * visitor.
+   * 
+   * @return <code>true</code> if the visitor was successfully visited
+   */
+  private boolean visit(ErrorContext logger, String internalName,
+      ClassVisitor visitor) {
+    assert Name.isInternalName(internalName) : "internalName";
+    logger.spam("Visiting " + internalName);
+    InputStream inputStream = null;
+    try {
+      inputStream = loader.getResourceAsStream(internalName + ".class");
+      if (inputStream == null) {
+        logger.poison("Could not find class file for " + internalName);
+        return false;
+      }
+      ClassReader reader = new ClassReader(inputStream);
+      reader.accept(visitor, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG
+          | ClassReader.SKIP_FRAMES);
+      return true;
+    } catch (IOException e) {
+      logger.poison("Unable to open " + internalName, e);
+    } finally {
+      if (inputStream != null) {
+        try {
+          inputStream.close();
+        } catch (IOException ignored) {
+        }
+      }
+    }
+    return false;
+  }
+}
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestProcessingException.java b/user/src/com/google/gwt/requestfactory/server/RequestProcessingException.java
index 91485a2..16e81f3 100644
--- a/user/src/com/google/gwt/requestfactory/server/RequestProcessingException.java
+++ b/user/src/com/google/gwt/requestfactory/server/RequestProcessingException.java
@@ -20,7 +20,7 @@
  * an unexpected exception is caught. Includes an appropriate
  * response of T to send to the client.
  */
-public class RequestProcessingException extends Exception {
+class RequestProcessingException extends Exception {
   private final Object response;
 
   /**
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestProcessor.java b/user/src/com/google/gwt/requestfactory/server/RequestProcessor.java
index 93dd64e..ed72beb 100644
--- a/user/src/com/google/gwt/requestfactory/server/RequestProcessor.java
+++ b/user/src/com/google/gwt/requestfactory/server/RequestProcessor.java
@@ -21,7 +21,7 @@
  * requests, and a serialized return value of the same type is returned.
  * @param <T> the type of encoding used to serialize the request (e.g. String)
  */
-public interface RequestProcessor<T> {
+interface RequestProcessor<T> {
   /**
    * Decodes request, invokes methods, and re-encoded resulting return values.
    */
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestProperty.java b/user/src/com/google/gwt/requestfactory/server/RequestProperty.java
index b1aeb0c..31a948c 100644
--- a/user/src/com/google/gwt/requestfactory/server/RequestProperty.java
+++ b/user/src/com/google/gwt/requestfactory/server/RequestProperty.java
@@ -23,7 +23,7 @@
 /**
  * Represents one piece in a property reference sequence.
  */
-public class RequestProperty implements Iterable<RequestProperty> {
+class RequestProperty implements Iterable<RequestProperty> {
 
   /**
    * Merge two property chains.
diff --git a/user/src/com/google/gwt/requestfactory/server/RequestSecurityProvider.java b/user/src/com/google/gwt/requestfactory/server/RequestSecurityProvider.java
index 9a404af..439f997 100644
--- a/user/src/com/google/gwt/requestfactory/server/RequestSecurityProvider.java
+++ b/user/src/com/google/gwt/requestfactory/server/RequestSecurityProvider.java
@@ -19,7 +19,7 @@
  * Enforces security policy for operations and classes, as well as permitting
  * request obfuscation.
  */
-public interface RequestSecurityProvider {
+interface RequestSecurityProvider {
 
   /**
    * Throws exception if argument is not accessible via remote requests.
diff --git a/user/src/com/google/gwt/requestfactory/server/SampleDataPopulator.java b/user/src/com/google/gwt/requestfactory/server/SampleDataPopulator.java
deleted file mode 100644
index 2ffd72e..0000000
--- a/user/src/com/google/gwt/requestfactory/server/SampleDataPopulator.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright 2010 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.requestfactory.server;
-
-import com.google.gwt.requestfactory.client.DefaultRequestTransport;
-import com.google.gwt.requestfactory.shared.impl.Constants;
-
-import org.apache.http.HttpEntity;
-import org.apache.http.HttpResponse;
-import org.apache.http.HttpStatus;
-import org.apache.http.client.HttpClient;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.impl.client.DefaultHttpClient;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.UnsupportedEncodingException;
-
-/**
- * Class to populate the datastore with sample data in a JSON file.
- */
-public class SampleDataPopulator {
-
-  public static void main(String args[]) {
-    // TODO: cleanup argument processing and error reporting.
-    if (args.length < 2) {
-      printHelp();
-      System.exit(-1);
-    }
-    try {
-      if (!args[0].endsWith(DefaultRequestTransport.URL)) {
-        System.err.println("Please check your URL string " + args[0]
-            + ", it should end with " + DefaultRequestTransport.URL + ", exiting");
-        System.exit(-1);
-      }
-      SampleDataPopulator populator = new SampleDataPopulator(args[0], args[1]);
-      populator.populate();
-    } catch (Exception ex) {
-      ex.printStackTrace();
-      printHelp();
-    }
-  }
-
-  private static void printHelp() {
-    StringBuffer sb = new StringBuffer();
-    sb.append("\n");
-    sb.append("Requires two arguments: the URL to post the JSON data and the path to the JSON data file.");
-    System.err.println(sb.toString());
-  }
-
-  private final String url;
-
-  private final String filePathName;
-
-  SampleDataPopulator(String url, String filePathName) {
-    this.url = url;
-    this.filePathName = filePathName;
-  }
-
-  public void populate() throws JSONException, IOException {
-    JSONObject jsonObject = readAsJsonObject(readFileAsString(filePathName));
-    postJsonFile(jsonObject);
-  }
-
-  private void postJsonFile(JSONObject contentData) throws IOException,
-      JSONException {
-    HttpPost post = new HttpPost(url);
-    JSONObject request = new JSONObject();
-    request.put(Constants.OPERATION_TOKEN, "DOESNT_WORK");
-    request.put(Constants.CONTENT_TOKEN, contentData);
-    StringEntity reqEntity = new StringEntity(request.toString());
-    post.setEntity(reqEntity);
-    HttpClient client = new DefaultHttpClient();
-    HttpResponse response = client.execute(post);
-    HttpEntity resEntity = response.getEntity();
-    if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
-      System.out.println("SUCCESS: Put " + resEntity.getContentLength()
-          + " records in the datastore!");
-      return;
-    }
-    System.err.println("POST failed: Status line " + response.getStatusLine()
-        + ", please check your URL");
-  }
-
-  private JSONObject readAsJsonObject(String string) throws JSONException {
-    JSONObject jsonObject = new JSONObject(string);
-    return jsonObject;
-  }
-
-  // ugly method, refactor later when cleaning up this class.
-  private byte[] readFileAsBytes(String filePathName) {
-    File file = new File(filePathName);
-    FileInputStream fileInputStream = null;
-    byte bytes[] = null;
-    try {
-      fileInputStream = new FileInputStream(file);
-      int byteLength = (int) file.length();
-      bytes = new byte[byteLength];
-      int byteOffset = 0;
-      while (byteOffset < byteLength) {
-        int bytesReadCount = fileInputStream.read(bytes, byteOffset, byteLength
-            - byteOffset);
-        if (bytesReadCount == -1) {
-          return null;
-        }
-        byteOffset += bytesReadCount;
-      }
-    } catch (IOException e) {
-      // Ignored.
-    } finally {
-      try {
-        if (fileInputStream != null) {
-          fileInputStream.close();
-        }
-      } catch (IOException e) {
-        // ignored
-      }
-    }
-    return bytes;
-  }
-  
-  private String readFileAsString(String filePathName) {
-    byte bytes[] = readFileAsBytes(filePathName);
-    if (bytes != null) {
-      try {
-        return new String(bytes, "UTF-8");
-      } catch (UnsupportedEncodingException e) {
-        // Ignored.
-      }
-      return null;
-    }
-    return null;
-  }
-
-}
diff --git a/user/src/com/google/gwt/requestfactory/server/SignatureAdapter.java b/user/src/com/google/gwt/requestfactory/server/SignatureAdapter.java
new file mode 100644
index 0000000..ebd6299
--- /dev/null
+++ b/user/src/com/google/gwt/requestfactory/server/SignatureAdapter.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2010 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.requestfactory.server;
+
+import com.google.gwt.dev.asm.signature.SignatureVisitor;
+
+/**
+ * An empty implementation of SignatureVisitor, used by
+ * {@link RequestFactoryInterfaceValidator}. This is a copy of the dev package's
+ * EmptySignatureVisitor.
+ */
+class SignatureAdapter implements SignatureVisitor {
+
+  private static final SignatureAdapter ignore = new SignatureAdapter();
+
+  public SignatureVisitor visitArrayType() {
+    return ignore;
+  }
+
+  public void visitBaseType(char descriptor) {
+  }
+
+  public SignatureVisitor visitClassBound() {
+    return ignore;
+  }
+
+  public void visitClassType(String name) {
+  }
+
+  public void visitEnd() {
+  }
+
+  public SignatureVisitor visitExceptionType() {
+    return ignore;
+  }
+
+  public void visitFormalTypeParameter(String name) {
+  }
+
+  public void visitInnerClassType(String name) {
+  }
+
+  public SignatureVisitor visitInterface() {
+    return ignore;
+  }
+
+  public SignatureVisitor visitInterfaceBound() {
+    return ignore;
+  }
+
+  public SignatureVisitor visitParameterType() {
+    return ignore;
+  }
+
+  public SignatureVisitor visitReturnType() {
+    return ignore;
+  }
+
+  public SignatureVisitor visitSuperclass() {
+    return ignore;
+  }
+
+  public void visitTypeArgument() {
+  }
+
+  public SignatureVisitor visitTypeArgument(char wildcard) {
+    return ignore;
+  }
+
+  public void visitTypeVariable(String name) {
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/requestfactory/shared/ProxyFor.java b/user/src/com/google/gwt/requestfactory/shared/ProxyFor.java
index 7a8c747..4da1afe 100644
--- a/user/src/com/google/gwt/requestfactory/shared/ProxyFor.java
+++ b/user/src/com/google/gwt/requestfactory/shared/ProxyFor.java
@@ -21,12 +21,13 @@
 import java.lang.annotation.Target;
 
 /**
- * Annotation on Record classes specifying 'type'. 'type'
- * represents the server-side counterpart of the Record.
+ * Annotation on EntityProxy classes specifying the domain (server-side) object
+ * type.
+ * 
+ * @see ProxyForName
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface ProxyFor {
-
   Class<?> value();
 }
diff --git a/user/src/com/google/gwt/requestfactory/shared/ProxyForName.java b/user/src/com/google/gwt/requestfactory/shared/ProxyForName.java
new file mode 100644
index 0000000..fa3f5bd
--- /dev/null
+++ b/user/src/com/google/gwt/requestfactory/shared/ProxyForName.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010 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.requestfactory.shared;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation on EntityProxy classes specifying the domain (server-side) object
+ * type. This annotation can be used in place of {@link ProxyFor} if the domain
+ * object is not available to the GWT compiler or DevMode runtime.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface ProxyForName {
+  String value();
+}
diff --git a/user/src/com/google/gwt/requestfactory/shared/Service.java b/user/src/com/google/gwt/requestfactory/shared/Service.java
index 59f2cf5..29d8829 100644
--- a/user/src/com/google/gwt/requestfactory/shared/Service.java
+++ b/user/src/com/google/gwt/requestfactory/shared/Service.java
@@ -23,10 +23,11 @@
 /**
  * Annotation on Request classes specifying the server side implementations that
  * back them.
+ * 
+ * @see ServiceName
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface Service {
-
   Class<?> value();
 }
diff --git a/user/src/com/google/gwt/requestfactory/shared/ServiceName.java b/user/src/com/google/gwt/requestfactory/shared/ServiceName.java
new file mode 100644
index 0000000..beb72b6
--- /dev/null
+++ b/user/src/com/google/gwt/requestfactory/shared/ServiceName.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010 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.requestfactory.shared;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation on Request classes specifying the server side implementations that
+ * back them.This annotation can be used in place of {@link Service} if the
+ * service type is not available to the GWT compiler or DevMode runtime.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface ServiceName {
+  String value();
+}
diff --git a/user/src/com/google/gwt/requestfactory/shared/impl/CollectionProperty.java b/user/src/com/google/gwt/requestfactory/shared/impl/CollectionProperty.java
index 69ca68b..7c2ff23 100644
--- a/user/src/com/google/gwt/requestfactory/shared/impl/CollectionProperty.java
+++ b/user/src/com/google/gwt/requestfactory/shared/impl/CollectionProperty.java
@@ -18,11 +18,6 @@
 import java.util.Collection;
 
 /**
- * <p> <span style="color:red">Experimental API: This class is still under rapid
- * development, and is very likely to be deleted. Use it at your own risk.
- * </span> </p> Defines a property of a {@link com.google.gwt.requestfactory.shared.EntityProxy} that contains a
- * one-to-many set of related values.
- *
  * @param <C> the type of the Container, must be List or Set
  * @param <E> the type of the element the container contains
  */
diff --git a/user/src/com/google/gwt/requestfactory/shared/impl/EnumProperty.java b/user/src/com/google/gwt/requestfactory/shared/impl/EnumProperty.java
index 7a0e743..842d745 100644
--- a/user/src/com/google/gwt/requestfactory/shared/impl/EnumProperty.java
+++ b/user/src/com/google/gwt/requestfactory/shared/impl/EnumProperty.java
@@ -16,11 +16,6 @@
 package com.google.gwt.requestfactory.shared.impl;
 
 /**
- * <p>
- * <span style="color:red">Experimental API: This class is still under rapid
- * development, and is very likely to be deleted. Use it at your own risk.
- * </span>
- * </p>
  * Defines a property of a {@link com.google.gwt.requestfactory.shared.EntityProxy}.
  *
  * @param <V> the type of the property's value
diff --git a/user/src/com/google/gwt/requestfactory/shared/impl/Property.java b/user/src/com/google/gwt/requestfactory/shared/impl/Property.java
index 06bd8ba..15e8b84 100644
--- a/user/src/com/google/gwt/requestfactory/shared/impl/Property.java
+++ b/user/src/com/google/gwt/requestfactory/shared/impl/Property.java
@@ -16,11 +16,6 @@
 package com.google.gwt.requestfactory.shared.impl;
 
 /**
- * <p>
- * <span style="color:red">Experimental API: This class is still under rapid
- * development, and is very likely to be deleted. Use it at your own risk.
- * </span>
- * </p>
  * Defines a property of an {@link EntityProxy}.
  *
  * @param <V> the type of the property's value
diff --git a/user/src/com/google/gwt/requestfactory/shared/impl/TypeLibrary.java b/user/src/com/google/gwt/requestfactory/shared/impl/TypeLibrary.java
index 6431b51..7234528 100644
--- a/user/src/com/google/gwt/requestfactory/shared/impl/TypeLibrary.java
+++ b/user/src/com/google/gwt/requestfactory/shared/impl/TypeLibrary.java
@@ -25,9 +25,6 @@
 import java.util.Set;
 
 /**
- * <p> <span style="color:red">Experimental API: This class is still under rapid
- * development, and is very likely to be deleted. Use it at your own risk.
- * </span> </p>
  * Utility methods for querying, encoding, and decoding typed
  * payload data.
  */
diff --git a/user/src/com/google/gwt/user/tools/WebAppCreator.java b/user/src/com/google/gwt/user/tools/WebAppCreator.java
index 8c5f373..c73c69c 100644
--- a/user/src/com/google/gwt/user/tools/WebAppCreator.java
+++ b/user/src/com/google/gwt/user/tools/WebAppCreator.java
@@ -371,6 +371,15 @@
     replacements.put("@testFolder", testFolder);
     replacements.put("@warFolder", warFolder);
 
+    // Add command to copy gwt-servlet-deps.jar into libs, unless this is a
+    // maven project. Maven projects should include libs as maven dependencies.
+    String copyServletDeps = "";
+    if (!maven) {
+      copyServletDeps = "<copy todir=\"" + warFolder + "/WEB-INF/lib\" "
+          + "file=\"${gwt.sdk}/gwt-servlet-deps.jar\" />";
+    }
+    replacements.put("@copyServletDeps", copyServletDeps);
+
     // Collect the list of server libs to include on the eclipse classpath.
     StringBuilder serverLibs = new StringBuilder();
     if (libDir.exists()) {
diff --git a/user/src/com/google/gwt/user/tools/project.ant.xmlsrc b/user/src/com/google/gwt/user/tools/project.ant.xmlsrc
index a1dd654..dacddf7 100644
--- a/user/src/com/google/gwt/user/tools/project.ant.xmlsrc
+++ b/user/src/com/google/gwt/user/tools/project.ant.xmlsrc
@@ -17,6 +17,7 @@
   <target name="libs" description="Copy libs to WEB-INF/lib">
     <mkdir dir="@warFolder/WEB-INF/lib" />
     <copy todir="@warFolder/WEB-INF/lib" file="${gwt.sdk}/gwt-servlet.jar" />
+    @copyServletDeps
     <!-- Add any additional server libs that need to be copied -->
   </target>
 
diff --git a/user/test/com/google/gwt/requestfactory/RequestFactoryJreSuite.java b/user/test/com/google/gwt/requestfactory/RequestFactoryJreSuite.java
index a6ad74a..3aa7f1b 100644
--- a/user/test/com/google/gwt/requestfactory/RequestFactoryJreSuite.java
+++ b/user/test/com/google/gwt/requestfactory/RequestFactoryJreSuite.java
@@ -19,6 +19,7 @@
 import com.google.gwt.requestfactory.rebind.model.RequestFactoryModelTest;
 import com.google.gwt.requestfactory.server.JsonRequestProcessorTest;
 import com.google.gwt.requestfactory.server.ReflectionBasedOperationRegistryTest;
+import com.google.gwt.requestfactory.server.RequestFactoryInterfaceValidatorTest;
 import com.google.gwt.requestfactory.server.RequestPropertyTest;
 
 import junit.framework.Test;
@@ -34,6 +35,7 @@
     suite.addTestSuite(SimpleEntityProxyIdTest.class);
     suite.addTestSuite(JsonRequestProcessorTest.class);
     suite.addTestSuite(ReflectionBasedOperationRegistryTest.class);
+    suite.addTestSuite(RequestFactoryInterfaceValidatorTest.class);
     suite.addTestSuite(RequestFactoryModelTest.class);
     suite.addTestSuite(RequestPropertyTest.class);
     return suite;
diff --git a/user/test/com/google/gwt/requestfactory/rebind/model/RequestFactoryModelTest.java b/user/test/com/google/gwt/requestfactory/rebind/model/RequestFactoryModelTest.java
index 42a821b..74d268a 100644
--- a/user/test/com/google/gwt/requestfactory/rebind/model/RequestFactoryModelTest.java
+++ b/user/test/com/google/gwt/requestfactory/rebind/model/RequestFactoryModelTest.java
@@ -26,8 +26,6 @@
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
 import com.google.gwt.requestfactory.server.TestContextImpl;
-import com.google.gwt.requestfactory.server.TestContextNoIdImpl;
-import com.google.gwt.requestfactory.server.TestContextNoVersionImpl;
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.InstanceRequest;
 import com.google.gwt.requestfactory.shared.ProxyFor;
@@ -49,8 +47,9 @@
 import java.util.SortedSet;
 
 /**
- * Test case for {@link com.google.gwt.requestfactory.rebind.model.RequestFactoryModel}
- * that uses mock CompilationStates.
+ * Test case for
+ * {@link com.google.gwt.requestfactory.rebind.model.RequestFactoryModel} that
+ * uses mock CompilationStates.
  */
 public class RequestFactoryModelTest extends TestCase {
 
@@ -64,8 +63,7 @@
     public EmptyMockJavaResource(Class<?> clazz) {
       super(clazz.getName());
 
-      code.append("package ").append(clazz.getPackage().getName())
-          .append(";\n");
+      code.append("package ").append(clazz.getPackage().getName()).append(";\n");
       code.append("public interface ").append(clazz.getSimpleName());
 
       int numParams = clazz.getTypeParameters().length;
@@ -103,15 +101,15 @@
     @Override
     protected CharSequence getContent() {
       String resourceName = getTypeName().replace('.', '/') + ".java";
-      InputStream stream = Thread.currentThread().getContextClassLoader()
-          .getResourceAsStream(resourceName);
+      InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(
+          resourceName);
       return Util.readStreamAsString(stream);
     }
   }
 
   private static TreeLogger createCompileLogger() {
-    PrintWriterTreeLogger logger = new PrintWriterTreeLogger(
-        new PrintWriter(System.err, true));
+    PrintWriterTreeLogger logger = new PrintWriterTreeLogger(new PrintWriter(
+        System.err, true));
     logger.setMaxDetail(TreeLogger.ERROR);
     return logger;
   }
@@ -125,7 +123,8 @@
   }
 
   public void testBadCollectionType() {
-    testModelWithMethodDecl("Request<SortedSet<Integer>> badReturnType();",
+    testModelWithMethodDecl(
+        "Request<SortedSet<Integer>> badReturnType();",
         "Requests that return collections may be declared with java.util.List or java.util.Set only");
   }
 
@@ -139,55 +138,10 @@
         "Invalid Request parameterization java.lang.Iterable");
   }
 
-  public void testMismatchedArityInstance() {
-    testModelWithMethodDecl(
-        "InstanceRequest<TestProxy, String> mismatchedArityInstance(TestProxy p, int x);",
-        "Parameter 0 of method TestContext.mismatchedArityInstance does not match method com.google.gwt.requestfactory.server.TestContextImpl.mismatchedArityInstance");
-  }
-
-  public void testMismatchedArityStatic() {
-    testModelWithMethodDecl("Request<String> mismatchedArityStatic(int x);",
-        "Method TestContext.mismatchedArityStatic parameters do not match same method on com.google.gwt.requestfactory.server.TestContextImpl");
-  }
-
-  public void testMismatchedModifierNonStatic() {
-    testModelWithMethodDecl(
-        "InstanceRequest<TestProxy, String> mismatchedNonStatic();",
-        "Method TestContext.mismatchedNonStatic is an instance method, while the corresponding method on com.google.gwt.requestfactory.server.TestContextImpl is static");
-  }
-
-  public void testMismatchedModifierStatic() {
-    testModelWithMethodDecl("Request<String> mismatchedStatic();",
-        "Method TestContext.mismatchedStatic is a static method, while the corresponding method on com.google.gwt.requestfactory.server.TestContextImpl is not");
-  }
-
-  public void testMismatchedParamType() {
-    testModelWithMethodDecl("Request<String> mismatchedParamType(Integer x);",
-        "Parameter 0 of method TestContext.mismatchedParamType does not match method com.google.gwt.requestfactory.server.TestContextImpl.mismatchedParamType");
-  }
-
-  public void testMismatchedReturnType() {
-    testModelWithMethodDecl("Request<String> mismatchedReturnType();",
-        "Return type of method TestContext.mismatchedReturnType does not match method com.google.gwt.requestfactory.server.TestContextImpl.mismatchedReturnType");
-  }
-
-  public void testMissingId() {
-    testModelWithMethodDeclArgs("Request<TestProxy> okMethodProxy();",
-        TestContextNoIdImpl.class.getName(),
-        TestContextNoIdImpl.class.getName(),
-        "The class com.google.gwt.requestfactory.server.TestContextNoIdImpl is missing method getId()");
-  }
-
-  public void testMissingMethod() {
-    testModelWithMethodDecl("Request<String> missingMethod();",
-        "Method t.TestContext.missingMethod has no corresponding public method on"
-            + " com.google.gwt.requestfactory.server.TestContextImpl");
-  }
-
   public void testMissingProxyFor() {
     testModelWithMethodDeclArgs("Request<TestProxy> okMethodProxy();",
         TestContextImpl.class.getName(), null,
-        "The t.TestProxy type does not have a @ProxyFor annotation");
+        "The t.TestProxy type does not have a @ProxyFor or @ProxyForName annotation");
   }
 
   public void testMissingService() {
@@ -196,13 +150,6 @@
         "RequestContext subtype t.TestContext is missing a @Service annotation");
   }
 
-  public void testMissingVersion() {
-    testModelWithMethodDeclArgs("Request<TestProxy> okMethodProxy();",
-        TestContextNoVersionImpl.class.getName(),
-        TestContextNoVersionImpl.class.getName(),
-        "The class com.google.gwt.requestfactory.server.TestContextNoVersionImpl is missing method getVersion()");
-  }
-
   public void testModelWithMethodDecl(final String clientMethodDecls,
       String... expected) {
     testModelWithMethodDeclArgs(clientMethodDecls,
@@ -250,8 +197,8 @@
       }
     });
 
-    CompilationState state = CompilationStateBuilder
-        .buildFrom(logger, javaResources);
+    CompilationState state = CompilationStateBuilder.buildFrom(logger,
+        javaResources);
 
     UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
     builder.setLowestLogLevel(TreeLogger.ERROR);
@@ -261,19 +208,14 @@
     builder.expectError(RequestFactoryModel.poisonedMessage(), null);
     UnitTestTreeLogger testLogger = builder.createLogger();
     try {
-      new RequestFactoryModel(testLogger,
-          state.getTypeOracle().findType("t.TestRequestFactory"));
+      new RequestFactoryModel(testLogger, state.getTypeOracle().findType(
+          "t.TestRequestFactory"));
       fail("Should have complained");
     } catch (UnableToCompleteException e) {
     }
     testLogger.assertCorrectLogEntries();
   }
 
-  public void testOverloadedMethod() {
-    testModelWithMethodDecl("Request<String> overloadedMethod();",
-        "Method t.TestContext.overloadedMethod is overloaded on com.google.gwt.requestfactory.server.TestContextImpl");
-  }
-
   private Set<Resource> getJavaResources(final String proxyClass) {
     MockJavaResource[] javaFiles = {new MockJavaResource("t.AddressProxy") {
       @Override
@@ -290,7 +232,7 @@
         return code;
       }
     }, new MockJavaResource("java.util.List") {
-      // Tests a Driver interface that extends more than RFED
+        // Tests a Driver interface that extends more than RFED
       @Override
       protected CharSequence getContent() {
         StringBuilder code = new StringBuilder();
@@ -300,7 +242,7 @@
         return code;
       }
     }, new MockJavaResource("java.util.Set") {
-      // Tests a Driver interface that extends more than RFED
+        // Tests a Driver interface that extends more than RFED
       @Override
       protected CharSequence getContent() {
         StringBuilder code = new StringBuilder();
@@ -310,7 +252,7 @@
         return code;
       }
     }, new MockJavaResource("java.util.SortedSet") {
-      // Tests a Driver interface that extends more than RFED
+        // Tests a Driver interface that extends more than RFED
       @Override
       protected CharSequence getContent() {
         StringBuilder code = new StringBuilder();
@@ -323,18 +265,18 @@
 
     Set<Resource> toReturn = new HashSet<Resource>(Arrays.asList(javaFiles));
 
-    toReturn.addAll(Arrays.asList(
-        new Resource[]{new EmptyMockJavaResource(Iterable.class),
-            new EmptyMockJavaResource(Property.class),
-            new EmptyMockJavaResource(EntityProxy.class),
-            new EmptyMockJavaResource(InstanceRequest.class),
-            new EmptyMockJavaResource(RequestFactory.class),
-            new EmptyMockJavaResource(Receiver.class),
+    toReturn.addAll(Arrays.asList(new Resource[] {
+        new EmptyMockJavaResource(Iterable.class),
+        new EmptyMockJavaResource(Property.class),
+        new EmptyMockJavaResource(EntityProxy.class),
+        new EmptyMockJavaResource(InstanceRequest.class),
+        new EmptyMockJavaResource(RequestFactory.class),
+        new EmptyMockJavaResource(Receiver.class),
 
-            new RealJavaResource(Request.class),
-            new RealJavaResource(Service.class),
-            new RealJavaResource(ProxyFor.class),
-            new EmptyMockJavaResource(RequestContext.class),}));
+        new RealJavaResource(Request.class),
+        new RealJavaResource(Service.class),
+        new RealJavaResource(ProxyFor.class),
+        new EmptyMockJavaResource(RequestContext.class),}));
     toReturn.addAll(Arrays.asList(JavaResourceBase.getStandardResources()));
     return toReturn;
   }
diff --git a/user/test/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidatorTest.java b/user/test/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidatorTest.java
new file mode 100644
index 0000000..0b1bad7
--- /dev/null
+++ b/user/test/com/google/gwt/requestfactory/server/RequestFactoryInterfaceValidatorTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2010 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.requestfactory.server;
+
+import com.google.gwt.requestfactory.server.RequestFactoryInterfaceValidator.ClassLoaderLoader;
+import com.google.gwt.requestfactory.shared.EntityProxy;
+import com.google.gwt.requestfactory.shared.InstanceRequest;
+import com.google.gwt.requestfactory.shared.ProxyFor;
+import com.google.gwt.requestfactory.shared.Request;
+import com.google.gwt.requestfactory.shared.RequestContext;
+import com.google.gwt.requestfactory.shared.Service;
+import com.google.gwt.requestfactory.shared.SimpleRequestFactory;
+
+import junit.framework.TestCase;
+
+import java.util.logging.Logger;
+
+/**
+ * JRE tests for {@link RequestFactoryInterfaceValidator}.
+ */
+public class RequestFactoryInterfaceValidatorTest extends TestCase {
+  static class Domain {
+    static int fooStatic(int a) {
+      return 0;
+    }
+
+    int foo(int a) {
+      return 0;
+    }
+  }
+
+  @ProxyFor(Domain.class)
+  interface DomainProxy extends EntityProxy {
+  }
+
+  interface DomainProxyMissingAnnotation extends EntityProxy {
+  }
+
+  static class DomainWithOverloads {
+    void foo() {
+    }
+
+    void foo(int a) {
+    }
+
+    String getId() {
+      return null;
+    }
+
+    int getVersion() {
+      return 0;
+    }
+  }
+
+  @ProxyFor(DomainWithOverloads.class)
+  interface DomainWithOverloadsProxy extends EntityProxy {
+    void foo();
+  }
+
+  class Foo {
+  }
+
+  interface RequestContextMissingAnnotation extends RequestContext {
+  }
+
+  @Service(Domain.class)
+  interface ServiceRequestMismatchedArity extends RequestContext {
+    InstanceRequest<DomainProxy, Integer> foo(int a, int b);
+
+    Request<Integer> fooStatic(int a, int b);
+  }
+
+  @Service(Domain.class)
+  interface ServiceRequestMismatchedParam extends RequestContext {
+    Request<Integer> foo(long a);
+  }
+
+  @Service(Domain.class)
+  interface ServiceRequestMismatchedReturn extends RequestContext {
+    Request<Long> foo(int a);
+  }
+
+  @Service(Domain.class)
+  interface ServiceRequestMismatchedStatic extends RequestContext {
+    Request<Integer> foo(int a);
+
+    InstanceRequest<DomainProxy, Integer> fooStatic(int a);
+  }
+
+  @Service(Domain.class)
+  interface ServiceRequestMissingMethod extends RequestContext {
+    Request<Integer> doesNotExist(int a);
+  }
+
+  RequestFactoryInterfaceValidator v;
+
+  public void testMismatchedArity() {
+    v.validateRequestContext(ServiceRequestMismatchedArity.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMismatchedParamType() {
+    v.validateRequestContext(ServiceRequestMismatchedParam.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMismatchedReturnType() {
+    v.validateRequestContext(ServiceRequestMismatchedReturn.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMismatchedStatic() {
+    v.validateRequestContext(ServiceRequestMismatchedStatic.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMissingDomainAnnotations() {
+    v.validateEntityProxy(DomainProxyMissingAnnotation.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMissingServiceAnnotations() {
+    v.validateRequestContext(RequestContextMissingAnnotation.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMissingIdAndVersion() {
+    v.validateEntityProxy(DomainProxy.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testMissingMethod() {
+    v.validateRequestContext(ServiceRequestMissingMethod.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  public void testOverloadedMethod() {
+    v.validateEntityProxy(DomainWithOverloadsProxy.class.getName());
+    assertTrue(v.isPoisoned());
+  }
+
+  /**
+   * Perform a full test of the RequestFactory used for most tests.
+   */
+  public void testTestCodeFactories() {
+    v.validateRequestFactory(SimpleRequestFactory.class.getName());
+    assertFalse(v.isPoisoned());
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    Logger logger = Logger.getLogger("");
+    v = new RequestFactoryInterfaceValidator(logger, new ClassLoaderLoader(
+        Thread.currentThread().getContextClassLoader()));
+  }
+}
diff --git a/user/test/com/google/gwt/requestfactory/shared/SimpleBarProxy.java b/user/test/com/google/gwt/requestfactory/shared/SimpleBarProxy.java
index e08a18d..6c8c1ae 100644
--- a/user/test/com/google/gwt/requestfactory/shared/SimpleBarProxy.java
+++ b/user/test/com/google/gwt/requestfactory/shared/SimpleBarProxy.java
@@ -15,13 +15,11 @@
  */
 package com.google.gwt.requestfactory.shared;
 
-import com.google.gwt.requestfactory.server.SimpleBar;
-
 /**
  * A simple entity used for testing. Has an int field and date field. Add other
  * data types as their support gets built in.
  */
-@ProxyFor(SimpleBar.class)
+@ProxyForName("com.google.gwt.requestfactory.server.SimpleBar")
 public interface SimpleBarProxy extends EntityProxy {
   Boolean getFindFails();
 
diff --git a/user/test/com/google/gwt/requestfactory/shared/SimpleBarRequest.java b/user/test/com/google/gwt/requestfactory/shared/SimpleBarRequest.java
index 0a8e7f2..f0196ad 100644
--- a/user/test/com/google/gwt/requestfactory/shared/SimpleBarRequest.java
+++ b/user/test/com/google/gwt/requestfactory/shared/SimpleBarRequest.java
@@ -21,7 +21,7 @@
 /**
  * Do nothing test interface.
  */
-@Service(com.google.gwt.requestfactory.server.SimpleBar.class)
+@ServiceName("com.google.gwt.requestfactory.server.SimpleBar")
 public interface SimpleBarRequest extends RequestContext {
 
   Request<Long> countSimpleBar();