Fix various nits in VM patch files.

sdk/lib/internal/iterable.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 339 matching lines @@
   final Iterable<S> _iterable;
   final _Transformation<S, T> _f;
 
   factory MappedIterable(Iterable<S> iterable, T function(S value)) {
     if (iterable is EfficientLengthIterable) {
       return new EfficientLengthMappedIterable<S, T>(iterable, function);
     }
     return new MappedIterable<S, T>._(iterable, function);
   }
 
-  MappedIterable._(this._iterable, T this._f(S element));
+  MappedIterable._(this._iterable, this._f);
 
   Iterator<T> get iterator => new MappedIterator<S, T>(_iterable.iterator, _f);
 
   // Length related functions are independent of the mapping.
   int get length => _iterable.length;
   bool get isEmpty => _iterable.isEmpty;
 
   // Index based lookup can be done before transforming.
   T get first => _f(_iterable.first);
   T get last => _f(_iterable.last);
   T get single => _f(_iterable.single);
   T elementAt(int index) => _f(_iterable.elementAt(index));
 }
 
 class EfficientLengthMappedIterable<S, T> extends MappedIterable<S, T>
     implements EfficientLengthIterable<T> {
   EfficientLengthMappedIterable(Iterable<S> iterable, T function(S value))
       : super._(iterable, function);
 }
 
 class MappedIterator<S, T> extends Iterator<T> {
   T _current;
   final Iterator<S> _iterator;
   final _Transformation<S, T> _f;
 
-  MappedIterator(this._iterator, T this._f(S element));
+  MappedIterator(this._iterator, this._f);
 
   bool moveNext() {
     if (_iterator.moveNext()) {
       _current = _f(_iterator.current);
       return true;
     }
     _current = null;
     return false;
   }
 
   T get current => _current;
 }
 
 /**
  * Specialized alternative to [MappedIterable] for mapped [List]s.
  *
  * Expects efficient `length` and `elementAt` on the source iterable.
  */
 class MappedListIterable<S, T> extends ListIterable<T> {
   final Iterable<S> _source;
   final _Transformation<S, T> _f;
 
-  MappedListIterable(this._source, T this._f(S value));
+  MappedListIterable(this._source, this._f);
 
   int get length => _source.length;
   T elementAt(int index) => _f(_source.elementAt(index));
 }
 
 
 typedef bool _ElementPredicate<E>(E element);
 
 class WhereIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
-  WhereIterable(this._iterable, bool this._f(E element));
+  WhereIterable(this._iterable, this._f);
 
   Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);
 
   // Specialization of [Iterable.map] to non-EfficientLengthIterable.
   Iterable<T> map<T>(T f(E element)) => new MappedIterable<E, T>._(this, f);
 }
 
 class WhereIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   final _ElementPredicate _f;
 
-  WhereIterator(this._iterator, bool this._f(E element));
+  WhereIterator(this._iterator, this._f);
 
   bool moveNext() {
     while (_iterator.moveNext()) {
       if (_f(_iterator.current)) {
         return true;
       }
     }
     return false;
   }
 
   E get current => _iterator.current;
 }
 
 typedef Iterable<T> _ExpandFunction<S, T>(S sourceElement);
 
 class ExpandIterable<S, T> extends Iterable<T> {
   final Iterable<S> _iterable;
   final _ExpandFunction<S, T> _f;
 
-  ExpandIterable(this._iterable, Iterable<T> this._f(S element));
+  ExpandIterable(this._iterable, this._f);
 
   Iterator<T> get iterator => new ExpandIterator<S, T>(_iterable.iterator, _f);
 }
 
 class ExpandIterator<S, T> implements Iterator<T> {
   final Iterator<S> _iterator;
   final _ExpandFunction<S, T> _f;
   // Initialize _currentExpansion to an empty iterable. A null value
   // marks the end of iteration, and we don't want to call _f before
   // the first moveNext call.
   Iterator<T> _currentExpansion = const EmptyIterator();
   T _current;
 
-  ExpandIterator(this._iterator, Iterable<T> this._f(S element));
+  ExpandIterator(this._iterator, this._f);
 
   T get current => _current;
 
   bool moveNext() {
     if (_currentExpansion == null) return false;
     while (!_currentExpansion.moveNext()) {
       _current = null;
       if (_iterator.moveNext()) {
         // If _f throws, this ends iteration. Otherwise _currentExpansion and
         // _current will be set again below.
@@ skipping 62 matching lines @@
   E get current {
     if (_remaining < 0) return null;
     return _iterator.current;
   }
 }
 
 class TakeWhileIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
-  TakeWhileIterable(this._iterable, bool this._f(E element));
+  TakeWhileIterable(this._iterable, this._f);
 
   Iterator<E> get iterator {
     return new TakeWhileIterator<E>(_iterable.iterator, _f);
   }
 }
 
 class TakeWhileIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   final _ElementPredicate<E> _f;
   bool _isFinished = false;
 
-  TakeWhileIterator(this._iterator, bool this._f(E element));
+  TakeWhileIterator(this._iterator, this._f);
 
   bool moveNext() {
     if (_isFinished) return false;
     if (!_iterator.moveNext() || !_f(_iterator.current)) {
       _isFinished = true;
       return false;
     }
     return true;
   }
 
@@ skipping 60 matching lines @@
     return _iterator.moveNext();
   }
 
   E get current => _iterator.current;
 }
 
 class SkipWhileIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
-  SkipWhileIterable(this._iterable, bool this._f(E element));
+  SkipWhileIterable(this._iterable, this._f);
 
   Iterator<E> get iterator {
     return new SkipWhileIterator<E>(_iterable.iterator, _f);
   }
 }
 
 class SkipWhileIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   final _ElementPredicate<E> _f;
   bool _hasSkipped = false;
 
-  SkipWhileIterator(this._iterator, bool this._f(E element));
+  SkipWhileIterator(this._iterator, this._f);
 
   bool moveNext() {
     if (!_hasSkipped) {
       _hasSkipped = true;
       while (_iterator.moveNext()) {
         if (!_f(_iterator.current)) return true;
       }
     }
     return _iterator.moveNext();
   }
@@ skipping 88 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }