Reduce strong mode errors and warnings

pkg/front_end/lib/src/fasta/source/outline_builder.dart

 // Copyright (c) 2016, 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.outline_builder;
 
 import 'package:kernel/ast.dart' show
     AsyncMarker,
     ProcedureKind;
 
@@ skipping 352 matching lines @@
     push(parameters);
   }
 
   @override
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
     List formals = popList(count);
     if (formals != null && formals.isNotEmpty) {
       var last = formals.last;
       if (last is List) {
-        var newList =
+        // TODO(sigmund): change `List newList` back to `var`.
+        //
+        // Note: in strong-mode the two `setRange` statements below fail
+        // dynamically because `formals` and `last` are not
+        // Iterable<FormalParameterBuilder>.
+        // A way to fix this without coping or iterating over
+        // the list of formals would be to split the optional arguments as a
+        // separate value on the parsing stack, then simply concatenate them:
+        //
+        //   List<FormalParameterBuilder> optionalFormals = pop();
+        //   List<FormalParameterBuilder> requiredFormals = popList(count);
+        //
+        // The resulting code might also be easier to follow.
+        List newList =

[ahe, 2017/02/07 11:03:08]

You don't need to add this comment, just do this:

List<FormalParameterBuilder> newList = ...;

[Siggi Cherem (dart-lang), 2017/02/07 21:59:26]

Here too: `var` is inferred as `List<FormalParameterBuilder>` under strong mode.
The problem is that `formals` and `last` are List<dynamic> and cannot be passed
to .setRange due to https://github.com/dart-lang/sdk/issues/28651.

Options that I believe are available to us right now:
 a- I can do what I did in body_builder (add an assignment to Iterable for
formals/last before we pass them to .setRange)
 b- remove the generic like I do here
 c- fix the parser to do what I describe in the comment
 d- keep the code as it was, and for now keep the 2 errors messages below in the
codebase until #28651 is fixed or (c) is done.

Eventually I'd like to make (c) happen: (a) and (b) are hiding a problem that
will resurface when we get to the point of making this run with strong checks in
2.0. However, I figure it's better to make that kind of change separately - if
you'd like me to do it sooner, I'd be happy to look into that.

Of the remaining options, I prefer (a) or (b). I kept it as (b) to make a single
change rather than 2, but I'm happy to change it to (a) instead if you prefer.

Since the comment felt a bit long, I moved the details to a bug and kept it
shorter here. Let me know what you think

             new List<FormalParameterBuilder>(formals.length - 1 + last.length);
         newList.setRange(0, formals.length - 1, formals);
         newList.setRange(formals.length - 1, newList.length, last);
         for (int i = 0; i < last.length; i++) {
           newList[i + formals.length - 1] = last[i];
         }
         formals = newList;
       }
     }
     if (formals != null) {
@@ skipping 167 matching lines @@
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }