anchor.diff:        _visit(node.expression);
   
     @override
  -  visitFormalParameter(FormalParameter node) => _emitFormalParameter(node);
  -
  -  _emitFormalParameter(FormalParameter node, {bool allowType: true}) {
  -    var id = _emitSimpleIdentifier(node.identifier, allowType: allowType);
  -
  +  visitFormalParameter(FormalParameter node) {
  +    var id = _emitParameter(node.element, declaration: true);
       var isRestArg = findAnnotation(node.element, isJsRestAnnotation) != null;
       return isRestArg ? new JS.RestParameter(id) : id;
     }
  
positive.code:       return js.call(code, member);
      }
  
      // initializing formal parameter, e.g. `Point(this.x)`
      if (element is ParameterElement &&
          element.isInitializingFormal &&
          element.isPrivate) {
        /// Rename private names so they don't shadow the private field symbol.
        /// The renamer would handle this, but it would prefer to rename the
        /// temporary used for the private symbol. Instead rename the parameter.
        return _getTemp(element, '${name.substring(1)}');
      }
  
      if (element is TemporaryVariableElement) {
  
negative.code:     List<JS.Parameter> params;
  
      var body = node.body;
      var type = node.element.type;
  
      JS.Node jsBody;
      if (body.isGenerator || body.isAsynchronous) {
        params = visitFormalParameterList(node.parameters, destructure: false);
        jsBody = _emitGeneratorFunctionBody(node.element, node.parameters, body);
      } else {
        params = visitFormalParameterList(node.parameters);
  
        // Chrome Canary does not accept default values with destructuring in
        // arrow functions yet (e.g. `({a} = {}) => 1`) but happily accepts them
        // with regular functions (e.g. `function({a} = {}) { return 1 }`).
        // Note that Firefox accepts both syntaxes just fine.
        // TODO(ochafik): Simplify this code when Chrome Canary catches up.
        bool destructureNamed = params.any((p) =>
            p is JS.DestructuredVariable &&
            p.structure is JS.ObjectBindingPattern);
  
        if (body is ExpressionFunctionBody && !destructureNamed) {
          // An arrow function can use the expression directly.
          // Note: this only works if we don't need to emit argument initializers.
          jsBody = _visit(body.expression);
        } else {
          jsBody = _visit(body);
        }
      }
  
      var fn = new JS.ArrowFun(params, jsBody,
          typeParams: _emitTypeFormals(type.typeFormals),
          returnType: emitTypeRef(type.returnType));
  