Reduce strong mode errors and warnings

pkg/front_end/lib/src/fasta/util/link.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.
 
 library fasta.util.link;
 
 import 'link_implementation.dart' show
     LinkBuilderImplementation,
     LinkEntry,
     LinkIterator,
@@ skipping 22 matching lines @@
       result.length = slowLength();
     }
     int i = 0;
     for (Link<T> link = this; !link.isEmpty; link = link.tail) {
       result[i++] = link.head;
     }
     return result;
   }
 
   /// Lazily maps over this linked list, returning an [Iterable].
-  Iterable map(dynamic fn(T item)) {
-    return new MappedLinkIterable<T, dynamic>(this, fn);
+  Iterable<K> map<K>(K fn(T item)) {
+    return new MappedLinkIterable<T, K>(this, fn);
   }
 
   /// Invokes `fn` for every item in the linked list and returns the results
   /// in a [List].
   List mapToList(dynamic fn(T item), {bool growable: true}) {
     List result;
     if (!growable) {
       result = new List(slowLength());
     } else {
       result = new List();
@@ skipping 32 matching lines @@
 
   String toString() => "[]";
 
   get length {
     throw new UnsupportedError('get:length');
   }
 
   int slowLength() => 0;
 
   // TODO(ahe): Remove this method?
-  bool contains(T element) {
+  bool contains(Object element) {
     for (Link<T> link = this; !link.isEmpty; link = link.tail) {
       if (link.head == element) return true;
     }
     return false;
   }
 
   // TODO(ahe): Remove this method?
   T get single {
     if (isEmpty) throw new StateError('No elements');
     if (!tail.isEmpty) throw new StateError('More than one element');
@@ skipping 16 matching lines @@
     return true;
   }
 
   Link copyWithout(e) => this;
 
   //
   // Unsupported Iterable<T> methods.
   //
   bool any(bool f(T e)) => _unsupported('any');
   T elementAt(int i) => _unsupported('elementAt');
-  Iterable expand(Iterable f(T e)) => _unsupported('expand');
+  Iterable<K> expand<K>(Iterable<K> f(T e)) => _unsupported('expand');
   T firstWhere(bool f(T e), {T orElse()}) => _unsupported('firstWhere');
-  fold(initialValue, combine(value, T element)) => _unsupported('fold');
+  K fold<K>(K initialValue, K combine(K value, T element)) => _unsupported('fold');
   T get last => _unsupported('get:last');
   T lastWhere(bool f(T e), {T orElse()}) => _unsupported('lastWhere');
   String join([separator = '']) => _unsupported('join');
   T reduce(T combine(T a, T b)) => _unsupported('reduce');
   T singleWhere(bool f(T e)) => _unsupported('singleWhere');
   Iterable<T> skipWhile(bool f(T e)) => _unsupported('skipWhile');
   Iterable<T> take(int n) => _unsupported('take');
   Iterable<T> takeWhile(bool f(T e)) => _unsupported('takeWhile');
   Set<T> toSet() => _unsupported('toSet');
   Iterable<T> where(bool f(T e)) => _unsupported('where');
 
   _unsupported(String method) => throw new UnsupportedError(method);
 }
 
 /// Builder object for creating linked lists using [Link] or fixed-length [List]
 /// objects.
 abstract class LinkBuilder<T> {
-  factory LinkBuilder() = LinkBuilderImplementation;
+  factory LinkBuilder() = LinkBuilderImplementation<T>;
 
   /// Prepends all elements added to the builder to [tail]. The resulting list
   /// is returned and the builder is cleared.
   Link<T> toLink([Link<T> tail = const Link()]);
 
   /// Creates a new fixed length containing all added elements. The
   /// resulting list is returned and the builder is cleared.
   List<T> toList();
 
   /// Adds the element [t] to the end of the list being built.
   Link<T> addLast(T t);
 
   /// Returns the first element in the list being built.
   T get first;
 
   /// Returns the number of elements in the list being built.
   final int length;
 
   /// Returns `true` if the list being built is empty.
   final bool isEmpty;
 
   /// Removes all added elements and resets the builder.
   void clear();
 }