diff --git a/user/src/com/google/gwt/user/RemoteService.gwt.xml b/user/src/com/google/gwt/user/RemoteService.gwt.xml
index 5d93d21..45cc4f2 100644
--- a/user/src/com/google/gwt/user/RemoteService.gwt.xml
+++ b/user/src/com/google/gwt/user/RemoteService.gwt.xml
@@ -17,7 +17,7 @@
 <!-- This module is typically inherited via com.google.gwt.user.User        -->
 <!--                                                                        -->
 <module>
-	<inherits name="com.google.gwt.user.HTTPRequest"/>
+	<inherits name="com.google.gwt.http.HTTP"/>  
 	
 	<!-- 
 		Declare a property to determine whether or not RPC type versioning 
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/RemoteServiceProxy.java b/user/src/com/google/gwt/user/client/rpc/impl/RemoteServiceProxy.java
new file mode 100644
index 0000000..4289a93
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/rpc/impl/RemoteServiceProxy.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2007 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.user.client.rpc.impl;
+
+import com.google.gwt.http.client.Request;
+import com.google.gwt.http.client.RequestBuilder;
+import com.google.gwt.http.client.RequestException;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.gwt.user.client.rpc.InvocationException;
+import com.google.gwt.user.client.rpc.SerializationException;
+import com.google.gwt.user.client.rpc.ServiceDefTarget;
+import com.google.gwt.user.client.rpc.impl.RequestCallbackAdapter.ResponseReader;
+
+/**
+ * Superclass for client-side
+ * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} proxies.
+ * 
+ * For internal use only.
+ */
+public abstract class RemoteServiceProxy implements ServiceDefTarget {
+  /**
+   * The module base URL as specified during construction.
+   */
+  private final String moduleBaseURL;
+
+  /**
+   * The name of the remote service interface that we will invoke methods on.
+   */
+  private final String remoteServiceIntfName;
+
+  /**
+   * URL of the
+   * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}.
+   */
+  private String remoteServiceURL;
+
+  /**
+   * The name of the serialization policy file specified during construction.
+   */
+  private final String serializationPolicyName;
+
+  /**
+   * The {@link Serializer} instance used to serialize and deserialize
+   * instances.
+   */
+  private final Serializer serializer;
+
+  protected RemoteServiceProxy(String moduleBaseURL, String remoteServiceURL,
+      String serializationPolicyName, String remoteServiceInfName,
+      Serializer serializer) {
+    this.moduleBaseURL = moduleBaseURL;
+    this.remoteServiceIntfName = remoteServiceInfName;
+    this.remoteServiceURL = remoteServiceURL;
+    this.serializer = serializer;
+    this.serializationPolicyName = serializationPolicyName;
+  }
+
+  /**
+   * Returns a
+   * {@link com.google.gwt.user.client.rpc.SerializationStreamReader SerializationStreamReader}
+   * that is ready for reading.
+   * 
+   * @param encoded string that encodes the response of an RPC request
+   * @return {@link com.google.gwt.user.client.rpc.SerializationStreamReader SerializationStreamReader}
+   *         that is ready for reading
+   * @throws SerializationException
+   */
+  public ClientSerializationStreamReader createStreamReader(String encoded)
+      throws SerializationException {
+    ClientSerializationStreamReader clientSerializationStreamReader = new ClientSerializationStreamReader(
+        getSerializer());
+    clientSerializationStreamReader.prepareToRead(RequestCallbackAdapter.getEncodedInstance(encoded));
+    return clientSerializationStreamReader;
+  }
+
+  /**
+   * Returns a
+   * {@link com.google.gwt.user.client.rpc.SerializationStreamWriter SerializationStreamWriter}
+   * that has had {@link ClientSerializationStreamWriter#prepareToWrite()}
+   * called on it and it has already had had the name of the remote service
+   * interface written as well.
+   * 
+   * @return {@link com.google.gwt.user.client.rpc.SerializationStreamWriter SerializationStreamWriter}
+   *         that has had
+   *         {@link ClientSerializationStreamWriter#prepareToWrite()} called on
+   *         it and it has already had had the name of the remote service
+   *         interface written as well
+   */
+  public ClientSerializationStreamWriter createStreamWriter() {
+    ClientSerializationStreamWriter clientSerializationStreamWriter = new ClientSerializationStreamWriter(
+        getSerializer(), getModuleBaseURL(), getSerializationPolicyName());
+    clientSerializationStreamWriter.prepareToWrite();
+    clientSerializationStreamWriter.writeString(remoteServiceIntfName);
+    return clientSerializationStreamWriter;
+  }
+
+  /**
+   * @see ServiceDefTarget#getServiceEntryPoint()
+   */
+  public String getServiceEntryPoint() {
+    return remoteServiceURL;
+  }
+
+  /**
+   * @see ServiceDefTarget#setServiceEntryPoint(String)
+   */
+  public void setServiceEntryPoint(String url) {
+    this.remoteServiceURL = url;
+  }
+
+  /**
+   * Performs a remote service method invocation.
+   * 
+   * @param <T> return type for the AsyncCallback
+   * @param responseReader instance used to read the return value of the
+   *          invocation
+   * @param requestData payload that encodes the addressing and arguments of the
+   *          RPC call
+   * @param callback callback handler
+   * 
+   * @return a {@link Request} object that can be used to track the request
+   */
+  protected <T> Request doInvoke(ResponseReader responseReader,
+      String requestData, AsyncCallback<T> callback) {
+
+    if (getServiceEntryPoint() == null) {
+      throw new NoServiceEntryPointSpecifiedException();
+    }
+
+    RequestCallbackAdapter<T> responseHandler = new RequestCallbackAdapter<T>(
+        getSerializer(), callback, responseReader);
+    RequestBuilder rb = new RequestBuilder(RequestBuilder.POST,
+        getServiceEntryPoint());
+    try {
+      return rb.sendRequest(requestData, responseHandler);
+    } catch (RequestException ex) {
+      InvocationException iex = new InvocationException(
+          "Unable to initiate the asynchronous service invocation -- check the network connection",
+          ex);
+      callback.onFailure(iex);
+    }
+
+    return null;
+  }
+
+  /**
+   * Returns the this proxy's module base URL.
+   * 
+   * @return this proxy's module base URL
+   */
+  protected String getModuleBaseURL() {
+    return moduleBaseURL;
+  }
+
+  /**
+   * Returns the name of the serialization policy.
+   * 
+   * @return name of the serialization policy
+   */
+  protected String getSerializationPolicyName() {
+    return serializationPolicyName;
+  }
+
+  /**
+   * Returns the {@link Serializer} instance used by this client proxy.
+   * 
+   * @return {@link Serializer} instance used by this client proxy
+   */
+  protected Serializer getSerializer() {
+    return serializer;
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/rpc/impl/RequestCallbackAdapter.java b/user/src/com/google/gwt/user/client/rpc/impl/RequestCallbackAdapter.java
new file mode 100644
index 0000000..9b8f2c2
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/rpc/impl/RequestCallbackAdapter.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2007 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.user.client.rpc.impl;
+
+import com.google.gwt.http.client.Request;
+import com.google.gwt.http.client.RequestCallback;
+import com.google.gwt.http.client.Response;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.gwt.user.client.rpc.SerializationException;
+import com.google.gwt.user.client.rpc.SerializationStreamReader;
+
+/**
+ * Adapter from a {@link RequestCallback} interface to an {@link AsyncCallback}
+ * interface.
+ * 
+ * For internal use only.
+ * 
+ * @param <T> the type parameter for the {@link AsyncCallback}
+ */
+public class RequestCallbackAdapter<T> implements RequestCallback {
+  /**
+   * Enumeration used to read specific return types out of a
+   * {@link SerializationStreamReader}.
+   */
+  public enum ResponseReader {
+    BOOLEAN {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readBoolean();
+      }
+    },
+
+    BYTE {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readByte();
+      }
+    },
+
+    CHAR {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readChar();
+      }
+    },
+
+    DOUBLE {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readDouble();
+      }
+    },
+
+    FLOAT {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readFloat();
+      }
+    },
+
+    INT {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readInt();
+      }
+    },
+
+    LONG {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readLong();
+      }
+    },
+
+    OBJECT {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readObject();
+      }
+    },
+
+    SHORT {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readShort();
+      }
+    },
+
+    STRING {
+      @Override
+      public Object read(SerializationStreamReader streamReader)
+          throws SerializationException {
+        return streamReader.readString();
+      }
+    },
+
+    VOID {
+      @Override
+      public Object read(SerializationStreamReader streamReader) {
+        return null;
+      }
+    };
+
+    public abstract Object read(SerializationStreamReader streamReader)
+        throws SerializationException;
+  }
+
+  /**
+   * Returns a string that encodes the result of a method invocation.
+   * Effectively, this just removes any headers from the encoded response.
+   * 
+   * @param encodedResponse
+   * @return string that encodes the result of a method invocation
+   */
+  static String getEncodedInstance(String encodedResponse) {
+    assert (!isInvocationException(encodedResponse));
+    return encodedResponse.substring(4);
+  }
+
+  private static boolean isInvocationException(String encodedResponse) {
+    return !isThrownException(encodedResponse)
+        && !isReturnValue(encodedResponse);
+  }
+
+  /**
+   * Return <code>true</code> if the encoded response contains a value
+   * returned by the method invocation.
+   * 
+   * @param encodedResponse
+   * @return <code>true</code> if the encoded response contains a value
+   *         returned by the method invocation
+   */
+  private static boolean isReturnValue(String encodedResponse) {
+    return encodedResponse.startsWith("//OK");
+  }
+
+  /**
+   * Return <code>true</code> if the encoded response contains a checked
+   * exception that was thrown by the method invocation.
+   * 
+   * @param encodedResponse
+   * @return <code>true</code> if the encoded response contains a checked
+   *         exception that was thrown by the method invocation
+   */
+  private static boolean isThrownException(String encodedResponse) {
+    return encodedResponse.startsWith("//EX");
+  }
+
+  /**
+   * {@link AsyncCallback} to notify or success or failure.
+   */
+  private final AsyncCallback<T> callback;
+
+  /**
+   * Instance which will read the expected return type out of the
+   * {@link SerializationStreamReader}.
+   */
+  private final ResponseReader responseReader;
+
+  /**
+   * {@link Serializer} instance used by the
+   * {@link ClientSerializationStreamReader} for serialization.
+   */
+  private final Serializer serializer;
+
+  public RequestCallbackAdapter(Serializer serializer,
+      AsyncCallback<T> callback, ResponseReader responseReader) {
+    assert (serializer != null);
+    assert (callback != null);
+    assert (responseReader != null);
+
+    this.serializer = serializer;
+    this.callback = callback;
+    this.responseReader = responseReader;
+  }
+
+  public void onError(Request request, Throwable exception) {
+    callback.onFailure(exception);
+  }
+
+  @SuppressWarnings("unchecked")
+  public void onResponseReceived(Request request, Response response) {
+    final ClientSerializationStreamReader streamReader = new ClientSerializationStreamReader(
+        serializer);
+    T result = null;
+    Throwable caught = null;
+    String encodedResponse = response.getText();
+    try {
+      if (isReturnValue(encodedResponse)) {
+        streamReader.prepareToRead(getEncodedInstance(encodedResponse));
+        result = (T) responseReader.read(streamReader);
+      } else if (isThrownException(encodedResponse)) {
+        streamReader.prepareToRead(getEncodedInstance(encodedResponse));
+        caught = (Throwable) streamReader.readObject();
+      } else {
+        assert (isInvocationException(encodedResponse));
+        caught = new com.google.gwt.user.client.rpc.InvocationException(
+            encodedResponse);
+      }
+    } catch (com.google.gwt.user.client.rpc.SerializationException e) {
+      caught = new com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException();
+    } catch (Throwable e) {
+      caught = e;
+    }
+
+    if (caught == null) {
+      callback.onSuccess(result);
+    } else {
+      callback.onFailure(caught);
+    }
+  }
+}
\ No newline at end of file
diff --git a/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java b/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
index 1438787..44df0f5 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/ProxyCreator.java
@@ -16,7 +16,6 @@
 package com.google.gwt.user.rebind.rpc;
 
 import com.google.gwt.core.client.GWT;
-import com.google.gwt.core.client.GWT.UncaughtExceptionHandler;
 import com.google.gwt.core.ext.GeneratorContext;
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
@@ -24,21 +23,16 @@
 import com.google.gwt.core.ext.typeinfo.JMethod;
 import com.google.gwt.core.ext.typeinfo.JPackage;
 import com.google.gwt.core.ext.typeinfo.JParameter;
-import com.google.gwt.core.ext.typeinfo.JParameterizedType;
 import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
 import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
 import com.google.gwt.dev.generator.NameFactory;
 import com.google.gwt.dev.util.Util;
-import com.google.gwt.user.client.ResponseTextHandler;
-import com.google.gwt.user.client.rpc.AsyncCallback;
-import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
-import com.google.gwt.user.client.rpc.InvocationException;
 import com.google.gwt.user.client.rpc.SerializationException;
-import com.google.gwt.user.client.rpc.ServiceDefTarget;
-import com.google.gwt.user.client.rpc.ServiceDefTarget.NoServiceEntryPointSpecifiedException;
+import com.google.gwt.user.client.rpc.impl.RemoteServiceProxy;
 import com.google.gwt.user.client.rpc.impl.ClientSerializationStreamReader;
 import com.google.gwt.user.client.rpc.impl.ClientSerializationStreamWriter;
+import com.google.gwt.user.client.rpc.impl.RequestCallbackAdapter.ResponseReader;
 import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
 import com.google.gwt.user.rebind.SourceWriter;
 import com.google.gwt.user.server.rpc.SerializationPolicyLoader;
@@ -49,6 +43,8 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Creates a client-side proxy for a
@@ -58,25 +54,34 @@
 class ProxyCreator {
   private static final String ENTRY_POINT_TAG = "gwt.defaultEntryPoint";
 
+  private static final Map<JPrimitiveType, ResponseReader> JPRIMITIVETYPE_TO_RESPONSEREADER = new HashMap<JPrimitiveType, ResponseReader>();
+
   private static final String PROXY_SUFFIX = "_Proxy";
 
-  /*
-   * This method returns the real type name. Currently, it only affects
-   * JParameterizedType since their names are not legal Java names.
-   */
-  private static String getJavaTypeName(JType type) {
-    JParameterizedType parameterizedType = type.isParameterized();
-    if (parameterizedType != null) {
-      return parameterizedType.getRawType().getQualifiedSourceName();
-    }
-
-    return type.getQualifiedSourceName();
-  }
-
   private boolean enforceTypeVersioning;
 
   private JClassType serviceIntf;
 
+  {
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.BOOLEAN,
+        ResponseReader.BOOLEAN);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.BYTE,
+        ResponseReader.BYTE);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.CHAR,
+        ResponseReader.CHAR);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.DOUBLE,
+        ResponseReader.DOUBLE);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.FLOAT,
+        ResponseReader.FLOAT);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.INT, ResponseReader.INT);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.LONG,
+        ResponseReader.LONG);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.SHORT,
+        ResponseReader.SHORT);
+    JPRIMITIVETYPE_TO_RESPONSEREADER.put(JPrimitiveType.VOID,
+        ResponseReader.VOID);
+  }
+
   public ProxyCreator(JClassType serviceIntf) {
     assert (serviceIntf.isInterface() != null);
     this.serviceIntf = serviceIntf;
@@ -89,19 +94,31 @@
    */
   public String create(TreeLogger logger, GeneratorContext context)
       throws UnableToCompleteException {
-    SourceWriter srcWriter = getSourceWriter(logger, context);
+    TypeOracle typeOracle = context.getTypeOracle();
+
+    JClassType serviceAsync = typeOracle.findType(serviceIntf.getQualifiedSourceName()
+        + "Async");
+    if (serviceAsync == null) {
+      logger.branch(TreeLogger.ERROR,
+          "Could not find an asynchronous version for the service interface "
+              + serviceIntf.getQualifiedSourceName(), null);
+      RemoteServiceAsyncValidator.logValidAsyncInterfaceDeclaration(logger,
+          serviceIntf);
+      throw new UnableToCompleteException();
+    }
+
+    SourceWriter srcWriter = getSourceWriter(logger, context, serviceAsync);
     if (srcWriter == null) {
       return getProxyQualifiedName();
     }
 
-    TypeOracle typeOracle = context.getTypeOracle();
-
     // Make sure that the async and synchronous versions of the RemoteService
     // agree with one another
     //
     RemoteServiceAsyncValidator rsav = new RemoteServiceAsyncValidator(logger,
         typeOracle);
-    rsav.validateRemoteServiceAsync(logger, serviceIntf);
+    Map<JMethod, JMethod> syncMethToAsyncMethMap = rsav.validate(logger,
+        serviceIntf, serviceAsync);
 
     // Determine the set of serializable types
     SerializableTypeOracleBuilder stob = new SerializableTypeOracleBuilder(
@@ -121,290 +138,36 @@
 
     generateProxyFields(srcWriter, sto, serializationPolicyStrongName);
 
-    generateServiceDefTargetImpl(srcWriter);
+    String typeSerializerName = sto.getTypeSerializerQualifiedName(serviceIntf);
+    generateProxyContructor(srcWriter, sto, serializationPolicyStrongName,
+        typeSerializerName);
 
-    generateProxyMethods(srcWriter, sto);
+    generateProxyMethods(srcWriter, sto, syncMethToAsyncMethMap);
 
     srcWriter.commit(logger);
 
     return getProxyQualifiedName();
   }
 
-  /*
-   * Given a type emit an expression for calling the correct
-   * SerializationStreamReader method which reads the corresponding instance out
-   * of the stream.
-   */
-  protected final void generateDecodeCall(SourceWriter w, JType type) {
-    w.print("streamReader.");
-    w.print(Shared.getStreamReadMethodNameFor(type) + "()");
-  }
-
-  /*
-   * Given a type emit an expression for calling the correct
-   * SerializationStreamWriter method which writes that type into the stream.
-   */
-  protected void generateEncodeCall(SourceWriter w, JParameter parameter) {
-    JType paramType = parameter.getType();
-    w.print("streamWriter.");
-    w.print(Shared.getStreamWriteMethodNameFor(paramType));
-    w.println("(" + parameter.getName() + ");");
-  }
-
-  /*
-   * Calls the __ version to encode.
-   */
-  private void generateAsynchronousProxyMethod(SourceWriter w, JMethod method) {
-
-    JType returnType = method.getReturnType();
-    JParameter[] params = method.getParameters();
-
-    NameFactory nameFactory = new NameFactory();
-
-    for (int i = 0; i < params.length; ++i) {
-      nameFactory.addName(params[i].getName());
-    }
-
-    w.println();
-    w.print("public void " + method.getName() + "(");
-    int i;
-    for (i = 0; i < params.length; i++) {
-      JParameter param = params[i];
-      w.print((i > 0 ? ", " : "") + getJavaTypeName(param.getType()) + " "
-          + param.getName());
-    }
-
-    w.println((i > 0 ? ", final " : "final ") + AsyncCallback.class.getName()
-        + " callback) {");
-    w.indent();
-    w.println("final "
-        + (ClientSerializationStreamReader.class.getName()
-            + " streamReader = new "
-            + ClientSerializationStreamReader.class.getName() + "(SERIALIZER);"));
-    w.println("final "
-        + (ClientSerializationStreamWriter.class.getName()
-            + " streamWriter = new "
-            + ClientSerializationStreamWriter.class.getName() + "(SERIALIZER, GWT.getModuleBaseURL(), SERIALIZATION_POLICY);"));
-    w.println("try {");
-    w.indent();
-    {
-      w.print("__" + method.getName() + "(streamWriter");
-      for (i = 0; i < params.length; i++) {
-        w.print(", " + params[i].getName());
-      }
-      w.println(");");
-    }
-    w.outdent();
-
-    String exceptionName = nameFactory.createName("e");
-    w.println("} catch (" + SerializationException.class.getName() + " "
-        + exceptionName + ") {");
-    w.indentln("callback.onFailure(" + exceptionName + ");");
-    w.indentln("return;");
-    w.println("}");
-
-    // Generate the async response handler.
-    //
-    w.println(ResponseTextHandler.class.getName() + " handler = new "
-        + ResponseTextHandler.class.getName() + "() {");
-    w.indent();
-    {
-      w.println("public final void onCompletion(String encodedResponse) {");
-      w.indent();
-      {
-        w.println("UncaughtExceptionHandler handler = GWT.getUncaughtExceptionHandler();");
-        w.println("if (handler != null)");
-        w.indent();
-        {
-          w.println("onCompletionAndCatch(encodedResponse, handler);");
-        }
-        w.outdent();
-        w.println("else");
-        w.indent();
-        {
-          w.println("onCompletionImpl(encodedResponse);");
-        }
-        w.outdent();
-      }
-      w.outdent();
-      w.println("}");
-
-      w.println("private void onCompletionAndCatch(String encodedResponse, UncaughtExceptionHandler handler) {");
-      w.indent();
-      {
-        w.println("try {");
-        w.indent();
-        {
-          w.println("onCompletionImpl(encodedResponse);");
-        }
-        w.outdent();
-        w.println("} catch (Throwable e) {");
-        w.indent();
-        {
-          w.println("handler.onUncaughtException(e);");
-        }
-        w.outdent();
-        w.println("}");
-      }
-      w.outdent();
-      w.println("}");
-
-      w.println("private void onCompletionImpl(String encodedResponse) {");
-      w.indent();
-      {
-        w.println("Object result = null;");
-        w.println("Throwable caught = null;");
-        w.println("try {");
-        w.indent();
-        {
-          w.println("if (encodedResponse.startsWith(\"//OK\")) {");
-          w.indent();
-          {
-            w.println("streamReader.prepareToRead(encodedResponse.substring(4));");
-            w.print("result = ");
-
-            JPrimitiveType primitive = returnType.isPrimitive();
-            if (primitive == JPrimitiveType.VOID) {
-              w.print("null");
-            } else {
-              if (primitive != null) {
-                w.print("new ");
-                w.print(getObjectWrapperName(primitive));
-                w.print("(");
-                generateDecodeCall(w, returnType);
-                w.print(")");
-              } else {
-                generateDecodeCall(w, returnType);
-              }
-            }
-            w.println(";");
-          }
-          w.outdent();
-          w.println("} else if (encodedResponse.startsWith(\"//EX\")) {");
-          w.indent();
-          {
-            w.println("streamReader.prepareToRead(encodedResponse.substring(4));");
-            w.println("caught = (Throwable) streamReader.readObject();");
-          }
-          w.outdent();
-          w.println("} else {");
-          w.indent();
-          {
-            w.println("caught = new " + InvocationException.class.getName()
-                + "(encodedResponse);");
-          }
-          w.outdent();
-          w.println("}");
-        }
-        w.outdent();
-        w.println("} catch (" + SerializationException.class.getName()
-            + " e) {");
-        w.indent();
-        {
-          w.println("caught = new "
-              + IncompatibleRemoteServiceException.class.getName() + "();");
-        }
-        w.outdent();
-        w.println("} catch (Throwable e) {");
-        w.indent();
-        {
-          w.println("caught = e;");
-        }
-        w.outdent();
-        w.println("}");
-
-        w.println("if (caught == null)");
-        w.indent();
-        {
-          w.println("callback.onSuccess(result);");
-        }
-        w.outdent();
-        w.println("else");
-        w.indent();
-        {
-          w.println("callback.onFailure(caught);");
-        }
-        w.outdent();
-      }
-      w.outdent();
-      w.println("}");
-    }
-    w.outdent();
-    w.println("};");
-
-    // Make the asynchronous invocation.
-    //
-    w.println("if (!com.google.gwt.user.client.HTTPRequest.asyncPost(getServiceEntryPoint(), streamWriter.toString(), handler))");
-    w.indentln("callback.onFailure(new "
-        + InvocationException.class.getName()
-        + "(\"Unable to initiate the asynchronous service invocation -- check the network connection\"));");
-    w.outdent();
-
-    w.println("}");
-  }
-
   /**
-   * Generate the code that addresses the service.
+   * Generate the proxy constructor and delegate to the superclass constructor
+   * using the default address for the
+   * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}.
    */
-  private void generateProxyEncode(SourceWriter w,
-      SerializableTypeOracle serializableTypeOracle, JMethod method) {
-    String methodName = method.getName();
-    JParameter[] params = method.getParameters();
-    w.println();
-    w.print("private void __" + methodName + "("
-        + ClientSerializationStreamWriter.class.getName() + " streamWriter");
-    for (int i = 0; i < params.length; i++) {
-      JParameter param = params[i];
-      w.print(", " + getJavaTypeName(param.getType()) + " " + param.getName());
-    }
-
-    w.println(") throws " + SerializationException.class.getName() + " {");
-    w.indent();
-
-    // Make sure that we have a service def class name specified.
-    //
-    w.println("if (getServiceEntryPoint() == null)");
-    String className = NoServiceEntryPointSpecifiedException.class.getName();
-    className = className.replace('$', '.');
-    w.indentln("throw new " + className + "();");
-
-    // Generate code to describe just enough meta data for the server to locate
-    // the service definition class and resolve the method overload.
-    //
-    w.println("streamWriter.prepareToWrite();");
-
-    if (!shouldEnforceTypeVersioning()) {
-      w.println("streamWriter.addFlags("
-          + ClientSerializationStreamReader.class.getName()
-          + ".SERIALIZATION_STREAM_FLAGS_NO_TYPE_VERSIONING);");
-    }
-
-    // Write the remote service interface's binary name
-    JClassType remoteService = method.getEnclosingType();
-    String remoteServiceBinaryName = serializableTypeOracle.getSerializedTypeName(remoteService);
-    w.println("streamWriter.writeString(\"" + remoteServiceBinaryName + "\");");
-
-    // Write the method name
-    w.println("streamWriter.writeString(\"" + methodName + "\");");
-
-    // Write the parameter count followed by the parameter values
-    w.println("streamWriter.writeInt(" + params.length + ");");
-    for (int i = 0; i < params.length; ++i) {
-      JParameter param = params[i];
-      w.println("streamWriter.writeString(\""
-          + serializableTypeOracle.getSerializedTypeName(param.getType())
-          + "\");");
-    }
-
-    // Encode the arguments.
-    //
-    for (int i = 0; i < params.length; i++) {
-      JParameter param = params[i];
-      generateEncodeCall(w, param);
-    }
-
-    w.outdent();
-    w.println("}");
+  private void generateProxyContructor(SourceWriter srcWriter,
+      SerializableTypeOracle serializableTypeOracle,
+      String serializationPolicyStrongName, String typeSerializerName) {
+    srcWriter.println("public " + getProxySimpleName() + "() {");
+    srcWriter.indent();
+    srcWriter.println("super(GWT.getModuleBaseURL(),");
+    srcWriter.indent();
+    srcWriter.println(getDefaultServiceDefName() + ",");
+    srcWriter.println("SERIALIZATION_POLICY, ");
+    srcWriter.println("REMOTE_SERVICE_INTERFACE_NAME, ");
+    srcWriter.println("SERIALIZER);");
+    srcWriter.outdent();
+    srcWriter.outdent();
+    srcWriter.println("}");
   }
 
   /**
@@ -413,47 +176,146 @@
   private void generateProxyFields(SourceWriter srcWriter,
       SerializableTypeOracle serializableTypeOracle,
       String serializationPolicyStrongName) {
+    // Initialize a field with binary name of the remote service interface
+    srcWriter.println("private static final String REMOTE_SERVICE_INTERFACE_NAME = \""
+        + serializableTypeOracle.getSerializedTypeName(serviceIntf) + "\";");
+    srcWriter.println("private static final String SERIALIZATION_POLICY =\""
+        + serializationPolicyStrongName + "\";");
     String typeSerializerName = serializableTypeOracle.getTypeSerializerQualifiedName(serviceIntf);
     srcWriter.println("private static final " + typeSerializerName
         + " SERIALIZER = new " + typeSerializerName + "();");
-    srcWriter.println("private static final String SERIALIZATION_POLICY =\""
-        + serializationPolicyStrongName + "\";");
-  }
-
-  private void generateProxyMethods(SourceWriter w,
-      SerializableTypeOracle serializableTypeOracle) {
-
-    JMethod[] methods = serviceIntf.getOverridableMethods();
-    for (int i = 0; i < methods.length; ++i) {
-      JMethod method = methods[i];
-      generateProxyEncode(w, serializableTypeOracle, method);
-      generateAsynchronousProxyMethod(w, method);
-    }
+    srcWriter.println();
   }
 
   /**
-   * Implements the ServiceDefTarget interface to allow clients to switch which
-   * back-end service definition we send calls to.
+   * Generates the client's asynchronous proxy method.
    */
-  private void generateServiceDefTargetImpl(SourceWriter w) {
-    String serverDefName = getDefaultServiceDefName();
-    if (serverDefName != null) {
-      serverDefName = "\"" + serverDefName + "\"";
-    } else {
-      serverDefName = "null";
+  private void generateProxyMethod(SourceWriter w,
+      SerializableTypeOracle serializableTypeOracle, JMethod syncMethod,
+      JMethod asyncMethod) {
+
+    w.println();
+
+    // Write the method signature
+    JType asyncReturnType = asyncMethod.getReturnType();
+    w.print("public ");
+    w.print(asyncReturnType.getQualifiedSourceName());
+    w.print(" ");
+    w.print(asyncMethod.getName() + "(");
+
+    boolean needsComma = false;
+    boolean needsTryCatchBlock = false;
+    NameFactory nameFactory = new NameFactory();
+    JParameter[] asyncParams = asyncMethod.getParameters();
+    for (int i = 0; i < asyncParams.length; ++i) {
+      JParameter param = asyncParams[i];
+
+      if (needsComma) {
+        w.print(", ");
+      } else {
+        needsComma = true;
+      }
+
+      /*
+       * Ignoring the AsyncCallback parameter, if any method requires a call to
+       * SerializationStreamWriter.writeObject we need a try catch block
+       */
+      JType paramType = param.getType();
+      if (i < asyncParams.length - 1
+          && paramType.isPrimitive() == null
+          && !paramType.getQualifiedSourceName().equals(
+              String.class.getCanonicalName())) {
+        needsTryCatchBlock = true;
+      }
+
+      w.print(paramType.getParameterizedQualifiedSourceName());
+      w.print(" ");
+
+      String paramName = param.getName();
+      nameFactory.addName(paramName);
+      w.print(paramName);
+    }
+
+    w.println(") {");
+
+    w.indent();
+
+    w.print(ClientSerializationStreamWriter.class.getSimpleName());
+    w.print(" ");
+    String streamWriterName = nameFactory.createName("streamWriter");
+    w.println(streamWriterName + " = createStreamWriter();");
+    w.println("// createStreamWriter() prepared the stream and wrote the name of RemoteService");
+    if (needsTryCatchBlock) {
+      w.println("try {");
+      w.indent();
+    }
+
+    if (!shouldEnforceTypeVersioning()) {
+      w.println(streamWriterName + ".addFlags("
+          + ClientSerializationStreamReader.class.getName()
+          + ".SERIALIZATION_STREAM_FLAGS_NO_TYPE_VERSIONING);");
+    }
+
+    // Write the method name
+    w.println(streamWriterName + ".writeString(\"" + syncMethod.getName()
+        + "\");");
+
+    // Write the parameter count followed by the parameter values
+    JParameter[] syncParams = syncMethod.getParameters();
+    w.println(streamWriterName + ".writeInt(" + syncParams.length + ");");
+    for (JParameter param : syncParams) {
+      w.println(streamWriterName + ".writeString(\""
+          + serializableTypeOracle.getSerializedTypeName(param.getType())
+          + "\");");
+    }
+
+    // Encode the arguments.
+    //
+    for (JParameter param : syncParams) {
+      JType paramType = param.getType();
+      w.print(streamWriterName + ".");
+      w.print(Shared.getStreamWriteMethodNameFor(paramType));
+      w.println("(" + param.getName() + ");");
+    }
+
+    JParameter callbackParam = asyncParams[asyncParams.length - 1];
+    String callbackName = callbackParam.getName();
+    if (needsTryCatchBlock) {
+      w.outdent();
+      w.print("} catch (SerializationException ");
+      String exceptionName = nameFactory.createName("ex");
+      w.println(exceptionName + ") {");
+      w.indent();
+      w.println(callbackName + ".onFailure(" + exceptionName + ");");
+      w.outdent();
+      w.println("}");
     }
 
     w.println();
-    w.println("String fServiceEntryPoint = " + serverDefName + ";");
-    w.println();
-    w.println("public String getServiceEntryPoint() { return fServiceEntryPoint; }");
-    w.println();
-    w.println("public void setServiceEntryPoint(String s) { fServiceEntryPoint = s; }");
+    if (asyncReturnType != JPrimitiveType.VOID) {
+      w.print("return ");
+    }
+
+    // Call the doInvoke method to actually send the request.
+    w.print("doInvoke(");
+    JType returnType = syncMethod.getReturnType();
+    w.print("ResponseReader." + getResponseReaderFor(returnType).name());
+    w.print(", " + streamWriterName + ".toString(), ");
+    w.println(callbackName + ");");
+    w.outdent();
+    w.println("}");
   }
 
-  private String getAsyncIntfQualifiedName() {
-    String asyncIntf = serviceIntf.getQualifiedSourceName() + "Async";
-    return asyncIntf;
+  private void generateProxyMethods(SourceWriter w,
+      SerializableTypeOracle serializableTypeOracle,
+      Map<JMethod, JMethod> syncMethToAsyncMethMap) {
+    JMethod[] syncMethods = serviceIntf.getOverridableMethods();
+    for (JMethod syncMethod : syncMethods) {
+      JMethod asyncMethod = syncMethToAsyncMethMap.get(syncMethod);
+      assert (asyncMethod != null);
+
+      generateProxyMethod(w, serializableTypeOracle, syncMethod, asyncMethod);
+    }
   }
 
   private String getDefaultServiceDefName() {
@@ -461,32 +323,10 @@
     if (metaData.length == 0) {
       return null;
     }
+
     return serviceIntf.getMetaData(ENTRY_POINT_TAG)[0][0];
   }
 
-  /*
-   * Determine the name of the object wrapper class to instantiate based on the
-   * the type of the primitive.
-   */
-  private String getObjectWrapperName(JPrimitiveType primitive) {
-    if (primitive == JPrimitiveType.INT) {
-      return "Integer";
-    } else if (primitive == JPrimitiveType.CHAR) {
-      return "Character";
-    }
-
-    return Shared.capitalize(primitive.getSimpleSourceName());
-  }
-
-  private String getPackageName() {
-    JPackage pkg = serviceIntf.getPackage();
-    if (pkg != null) {
-      return pkg.getName();
-    }
-
-    return "";
-  }
-
   private String getProxyQualifiedName() {
     String[] name = Shared.synthesizeTopLevelClassName(serviceIntf,
         PROXY_SUFFIX);
@@ -499,23 +339,43 @@
     return name[1];
   }
 
-  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContext ctx) {
-    PrintWriter printWriter = ctx.tryCreate(logger, getPackageName(),
+  private ResponseReader getResponseReaderFor(JType returnType) {
+    if (returnType.isPrimitive() != null) {
+      return JPRIMITIVETYPE_TO_RESPONSEREADER.get(returnType.isPrimitive());
+    }
+
+    if (returnType.getQualifiedSourceName().equals(
+        String.class.getCanonicalName())) {
+      return ResponseReader.STRING;
+    }
+
+    return ResponseReader.OBJECT;
+  }
+
+  private SourceWriter getSourceWriter(TreeLogger logger, GeneratorContext ctx,
+      JClassType serviceAsync) {
+    JPackage serviceIntfPkg = serviceAsync.getPackage();
+    String packageName = serviceIntfPkg == null ? "" : serviceIntfPkg.getName();
+    PrintWriter printWriter = ctx.tryCreate(logger, packageName,
         getProxySimpleName());
     if (printWriter == null) {
       return null;
     }
 
     ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(
-        getPackageName(), getProxySimpleName());
+        packageName, getProxySimpleName());
 
-    composerFactory.addImport(GWT.class.getName());
-    String className = UncaughtExceptionHandler.class.getName();
-    className = className.replace('$', '.');
-    composerFactory.addImport(className);
+    String[] imports = new String[] {
+        RemoteServiceProxy.class.getCanonicalName(),
+        ClientSerializationStreamWriter.class.getCanonicalName(),
+        GWT.class.getCanonicalName(), ResponseReader.class.getCanonicalName(),
+        SerializationException.class.getCanonicalName()};
+    for (String imp : imports) {
+      composerFactory.addImport(imp);
+    }
 
-    composerFactory.addImplementedInterface(ServiceDefTarget.class.getName());
-    composerFactory.addImplementedInterface(getAsyncIntfQualifiedName());
+    composerFactory.setSuperclass(RemoteServiceProxy.class.getSimpleName());
+    composerFactory.addImplementedInterface(serviceAsync.getParameterizedQualifiedSourceName());
 
     return composerFactory.createSourceWriter(ctx, printWriter);
   }
diff --git a/user/src/com/google/gwt/user/rebind/rpc/RemoteServiceAsyncValidator.java b/user/src/com/google/gwt/user/rebind/rpc/RemoteServiceAsyncValidator.java
index 3a1d3c6..93f53c0 100644
--- a/user/src/com/google/gwt/user/rebind/rpc/RemoteServiceAsyncValidator.java
+++ b/user/src/com/google/gwt/user/rebind/rpc/RemoteServiceAsyncValidator.java
@@ -22,10 +22,13 @@
 import com.google.gwt.core.ext.typeinfo.JPackage;
 import com.google.gwt.core.ext.typeinfo.JParameter;
 import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
+import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.core.ext.typeinfo.NotFoundException;
 import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.http.client.Request;
 import com.google.gwt.user.client.rpc.AsyncCallback;
 
+import java.util.HashMap;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -34,6 +37,47 @@
  * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
  */
 class RemoteServiceAsyncValidator {
+  static void logValidAsyncInterfaceDeclaration(TreeLogger logger,
+      JClassType remoteService) {
+    TreeLogger branch = logger.branch(TreeLogger.INFO,
+        "A valid definition for the asynchronous version of interface '"
+            + remoteService.getQualifiedSourceName() + "' would be:\n", null);
+    branch.log(TreeLogger.ERROR,
+        synthesizeAsynchronousInterfaceDefinition(remoteService), null);
+  }
+
+  private static String computeAsyncMethodSignature(JMethod syncMethod,
+      JClassType asyncCallbackClass) {
+    return computeInternalSignature(syncMethod) + "/"
+        + asyncCallbackClass.getQualifiedSourceName();
+  }
+
+  private static String computeInternalSignature(JMethod method) {
+    StringBuffer sb = new StringBuffer();
+    sb.setLength(0);
+    sb.append(method.getName());
+    JParameter[] params = method.getParameters();
+    for (JParameter param : params) {
+      sb.append("/");
+      JType paramType = param.getType();
+      sb.append(paramType.getErasedType().getQualifiedSourceName());
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Builds a map of asynchronous method internal signatures to the
+   * corresponding asynchronous {@link JMethod}.
+   */
+  private static Map<String, JMethod> initializeAsyncMethodMap(
+      JMethod[] asyncMethods) {
+    Map<String, JMethod> sigs = new TreeMap<String, JMethod>();
+    for (JMethod asyncMethod : asyncMethods) {
+      sigs.put(computeInternalSignature(asyncMethod), asyncMethod);
+    }
+    return sigs;
+  }
+
   private static String synthesizeAsynchronousInterfaceDefinition(
       JClassType serviceIntf) {
     StringBuffer sb = new StringBuffer();
@@ -82,14 +126,27 @@
     return sb.toString();
   }
 
+  private static void validationFailed(TreeLogger branch,
+      JClassType remoteService) throws UnableToCompleteException {
+    logValidAsyncInterfaceDeclaration(branch, remoteService);
+    throw new UnableToCompleteException();
+  }
+
+  /**
+   * {@link JClassType} for the {@link AsyncCallback} interface.
+   */
   private final JClassType asyncCallbackClass;
-  private final TypeOracle typeOracle;
+
+  /**
+   * {@link JClassType} for the {@link Request} class.
+   */
+  private final JClassType requestType;
 
   RemoteServiceAsyncValidator(TreeLogger logger, TypeOracle typeOracle)
       throws UnableToCompleteException {
-    this.typeOracle = typeOracle;
     try {
       asyncCallbackClass = typeOracle.getType(AsyncCallback.class.getName());
+      requestType = typeOracle.getType(Request.class.getCanonicalName());
     } catch (NotFoundException e) {
       logger.log(TreeLogger.ERROR, null, e);
       throw new UnableToCompleteException();
@@ -97,103 +154,74 @@
   }
 
   /**
-   * Checks that for there is an asynchronous
-   * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}
-   * interface and that it has an asynchronous version of every synchronous
-   * method.
+   * Checks that for every method on the synchronous remote service interface
+   * there is a corresponding asynchronous version in the asynchronous version
+   * of the remote service. If the validation succeeds, a map of synchronous to
+   * asynchronous methods is returned.
+   * 
+   * @param logger
+   * @param remoteService
+   * @return map of synchronous method to asynchronous method
    * 
    * @throws UnableToCompleteException if the asynchronous
    *           {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}
    *           was not found, or if it does not have an asynchronous method
    *           version of every synchronous one
    */
-  public void validateRemoteServiceAsync(TreeLogger logger,
-      JClassType remoteService) throws UnableToCompleteException {
+  public Map<JMethod, JMethod> validate(TreeLogger logger,
+      JClassType remoteService, JClassType remoteServiceAsync)
+      throws UnableToCompleteException {
     TreeLogger branch = logger.branch(TreeLogger.DEBUG,
         "Checking the synchronous interface '"
             + remoteService.getQualifiedSourceName()
             + "' against its asynchronous version '"
-            + remoteService.getQualifiedSourceName() + "Async'", null);
-    boolean failed = false;
-    JClassType serviceAsync = typeOracle.findType(remoteService.getQualifiedSourceName()
-        + "Async");
-    if (serviceAsync == null) {
-      failed = true;
-      branch.branch(TreeLogger.ERROR,
-          "Could not find an asynchronous version for the service interface "
-              + remoteService.getQualifiedSourceName(), null);
-    } else {
-      JMethod[] asyncMethods = serviceAsync.getOverridableMethods();
-      JMethod[] syncMethods = remoteService.getOverridableMethods();
+            + remoteServiceAsync.getQualifiedSourceName() + "'", null);
 
-      if (asyncMethods.length != syncMethods.length) {
-        branch.branch(TreeLogger.ERROR, "The asynchronous version of "
-            + remoteService.getQualifiedSourceName() + " has "
-            + (asyncMethods.length > syncMethods.length ? "more" : "less")
-            + " methods than the synchronous version", null);
+    // Sync and async versions must have the same number of methods
+    JMethod[] asyncMethods = remoteServiceAsync.getOverridableMethods();
+    JMethod[] syncMethods = remoteService.getOverridableMethods();
+    if (asyncMethods.length != syncMethods.length) {
+      branch.branch(TreeLogger.ERROR, "The asynchronous version of "
+          + remoteService.getQualifiedSourceName() + " has "
+          + (asyncMethods.length > syncMethods.length ? "more" : "less")
+          + " methods than the synchronous version", null);
+      validationFailed(branch, remoteService);
+    }
+
+    // Check that for every sync method there is a corresponding async method
+    boolean failed = false;
+    Map<String, JMethod> asyncMethodMap = initializeAsyncMethodMap(asyncMethods);
+    Map<JMethod, JMethod> syncMethodToAsyncMethodMap = new HashMap<JMethod, JMethod>();
+    for (JMethod syncMethod : syncMethods) {
+      String asyncSig = computeAsyncMethodSignature(syncMethod,
+          asyncCallbackClass);
+      JMethod asyncMethod = asyncMethodMap.get(asyncSig);
+      if (asyncMethod == null) {
+        branch.branch(TreeLogger.ERROR,
+            "Missing asynchronous version of the synchronous method '"
+                + syncMethod.getReadableDeclaration() + "'", null);
         failed = true;
       } else {
-        Map<String, JMethod> asyncMethodMap = initializeAsyncMethodMap(asyncMethods);
-        for (JMethod syncMethod : syncMethods) {
-          String asyncSig = computeAsyncMethodSignature(syncMethod);
-          JMethod asyncMethod = asyncMethodMap.get(asyncSig);
-          if (asyncMethod == null) {
-            branch.branch(TreeLogger.ERROR,
-                "Missing asynchronous version of the synchronous method '"
-                    + syncMethod.getReadableDeclaration() + "'", null);
-            failed = true;
-          } else if (asyncMethod.getReturnType() != JPrimitiveType.VOID) {
-            branch.branch(TreeLogger.ERROR,
-                "The asynchronous version of the synchronous method '"
-                    + syncMethod.getReadableDeclaration()
-                    + "' must have a 'void' return type", null);
-            failed = true;
-          }
+        // TODO if async param is parameterized make sure that the sync return
+        // type is assignable to the first type argument
+        JType returnType = asyncMethod.getReturnType();
+        if (returnType != JPrimitiveType.VOID && returnType != requestType) {
+          branch.branch(TreeLogger.ERROR,
+              "The asynchronous version of the synchronous method '"
+                  + syncMethod.getReadableDeclaration()
+                  + "' must have a return type of 'void' or '"
+                  + Request.class.getCanonicalName() + "'", null);
+          failed = true;
+        } else {
+          syncMethodToAsyncMethodMap.put(syncMethod, asyncMethod);
         }
       }
     }
 
     if (failed) {
-      logValidAsyncInterfaceDeclaration(branch, remoteService);
-      throw new UnableToCompleteException();
+      validationFailed(branch, remoteService);
     }
-  }
 
-  private String computeAsyncMethodSignature(JMethod syncMethod) {
-    return computeInternalSignature(syncMethod) + "/"
-        + asyncCallbackClass.getQualifiedSourceName();
-  }
-
-  private String computeInternalSignature(JMethod method) {
-    StringBuffer sb = new StringBuffer();
-    sb.setLength(0);
-    sb.append(method.getName());
-    JParameter[] params = method.getParameters();
-    for (JParameter param : params) {
-      sb.append("/");
-      sb.append(param.getType().getQualifiedSourceName());
-    }
-    return sb.toString();
-  }
-
-  /**
-   * Builds a map of asynchronous method internal signatures to the
-   * corresponding asynchronous {@link JMethod}.
-   */
-  private Map<String, JMethod> initializeAsyncMethodMap(JMethod[] asyncMethods) {
-    Map<String, JMethod> sigs = new TreeMap<String, JMethod>();
-    for (JMethod asyncMethod : asyncMethods) {
-      sigs.put(computeInternalSignature(asyncMethod), asyncMethod);
-    }
-    return sigs;
-  }
-
-  private void logValidAsyncInterfaceDeclaration(TreeLogger logger,
-      JClassType remoteService) {
-    TreeLogger branch = logger.branch(TreeLogger.INFO,
-        "A valid definition for the asynchronous version of interface '"
-            + remoteService.getQualifiedSourceName() + "' would be:\n", null);
-    branch.log(TreeLogger.ERROR,
-        synthesizeAsynchronousInterfaceDefinition(remoteService), null);
+    return syncMethodToAsyncMethodMap;
   }
 }
\ No newline at end of file
diff --git a/user/src/com/google/gwt/user/server/rpc/RPC.java b/user/src/com/google/gwt/user/server/rpc/RPC.java
index 836c81f..20ee0ef 100644
--- a/user/src/com/google/gwt/user/server/rpc/RPC.java
+++ b/user/src/com/google/gwt/user/server/rpc/RPC.java
@@ -160,7 +160,7 @@
    *           assignable to the requested {@link RemoteService} interface
    *           </ul>
    */
-  public static RPCRequest decodeRequest(String encodedRequest, Class type) {
+  public static RPCRequest decodeRequest(String encodedRequest, Class<?> type) {
     return decodeRequest(encodedRequest, type, null);
   }
 
@@ -216,7 +216,7 @@
    *           assignable to the requested {@link RemoteService} interface
    *           </ul>
    */
-  public static RPCRequest decodeRequest(String encodedRequest, Class type,
+  public static RPCRequest decodeRequest(String encodedRequest, Class<?> type,
       SerializationPolicyProvider serializationPolicyProvider) {
     if (encodedRequest == null) {
       throw new NullPointerException("encodedRequest cannot be null");
@@ -279,22 +279,21 @@
         }
       }
 
-      Method method = findInterfaceMethod(serviceIntf, serviceMethodName,
-          parameterTypes, true);
+      try {
+        Method method = serviceIntf.getMethod(serviceMethodName, parameterTypes);
 
-      if (method == null) {
+        Object[] parameterValues = new Object[parameterTypes.length];
+        for (int i = 0; i < parameterValues.length; i++) {
+          parameterValues[i] = streamReader.deserializeValue(parameterTypes[i]);
+        }
+
+        return new RPCRequest(method, parameterValues, serializationPolicy);
+
+      } catch (NoSuchMethodException e) {
         throw new IncompatibleRemoteServiceException(
             formatMethodNotFoundErrorMessage(serviceIntf, serviceMethodName,
                 parameterTypes));
       }
-
-      Object[] parameterValues = new Object[parameterTypes.length];
-      for (int i = 0; i < parameterValues.length; i++) {
-        parameterValues[i] = streamReader.deserializeValue(parameterTypes[i]);
-      }
-
-      return new RPCRequest(method, parameterValues, serializationPolicy);
-
     } catch (SerializationException ex) {
       throw new IncompatibleRemoteServiceException(ex.getMessage(), ex);
     }
@@ -578,29 +577,6 @@
     return bufferStr;
   }
 
-  /**
-   * Find the invoked method on either the specified interface or any super.
-   */
-  private static Method findInterfaceMethod(Class<?> intf, String methodName,
-      Class<?>[] paramTypes, boolean includeInherited) {
-    try {
-      return intf.getDeclaredMethod(methodName, paramTypes);
-    } catch (NoSuchMethodException e) {
-      if (includeInherited) {
-        Class<?>[] superintfs = intf.getInterfaces();
-        for (int i = 0; i < superintfs.length; i++) {
-          Method method = findInterfaceMethod(superintfs[i], methodName,
-              paramTypes, true);
-          if (method != null) {
-            return method;
-          }
-        }
-      }
-
-      return null;
-    }
-  }
-
   private static String formatIllegalAccessErrorMessage(Object target,
       Method serviceMethod) {
     StringBuffer sb = new StringBuffer();