anchor.diff:    }
   
     Future<Response> _process() async {
  -    var methodSymbol = _routeMethodSymbolForRequest(request);
  -    var handlerParameters = _parametersForRequest(request, methodSymbol);
  +    var key = _generateHandlerMethodKey(request.innerRequest.method, request.path.orderedVariableNames);
  +    var cachedMethod = _methodCache[this.runtimeType][key];
  +    if (cachedMethod == null) {
  +      return new Response.notFound();
  +    }
  +
  +    var methodSymbol = cachedMethod.methodSymbol;
  +    var handlerParameters = cachedMethod
  +        .orderedPathParameters
  +        .map((param) => _convertParameterWithMirror(this.request.path.variables[param.name], param.typeMirror))
  +        .toList();
   
       if (request.innerRequest.contentLength > 0) {
         if (_requestContentTypeIsSupported(request)) {
  
positive.code: 
  class _HTTPControllerCachedMethod {
    Symbol methodSymbol;
    List<String> orderedPathParameters = [];
  }
negative.code:             .firstWhere((attr) => attr.reflectee is HTTPMethod, orElse: () => null);
  
          if (methodAttrs != null) {
            List<_HTTPControllerCachedParameter> params = (declaration as MethodMirror)
                .parameters
                .where((pm) => !pm.isOptional)
                .map((pm) {
                  return new _HTTPControllerCachedParameter()
                      ..name = MirrorSystem.getName(pm.simpleName)
                      ..typeMirror = pm.type;
                })
                .toList();
  
            var generatedKey = _generateHandlerMethodKey((methodAttrs.reflectee as HTTPMethod).method, params.map((p) => p.name).toList());
            var cachedMethod = new _HTTPControllerCachedMethod()
              ..methodSymbol = key
              ..orderedPathParameters = params;
  