Incorporates feedback by Nicolas for UTF-8 bytes based scanner CL

sdk/lib/_internal/compiler/implementation/source_file.dart

 // Copyright (c) 2012, 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 source_file;
 
 import 'dart:math';
 import 'dart:convert' show UTF8;
 
 /**
@@ skipping 16 matching lines @@
   /**
    * The length of the string representation of this source file, i.e.,
    * equivalent to [:slowText().length:], but faster.
    */
   int get length;
 
   /**
    * Sets the string length of this source file. For source files based on UTF-8
    * byte arrays, the string length is computed and assigned by the scanner.
    */
-  set length(v);
+  set length(int v);
 
   /**
    * A map from line numbers to offsets in the string text representation of
    * this source file.
    */
   List<int> get lineStarts {
     if (lineStartsCache == null) {
       // When reporting errors during scanning, the line numbers are not yet
       // available and need to be computed using this slow path.
       lineStartsCache = lineStartsFromString(slowText());
     }
     return lineStartsCache;
   }
 
   /**
    * Sets the line numbers map for this source file. This map is computed and
    * assigned by the scanner, avoiding a separate traversal of the source file.
    *
    * The map contains one additional entry at the end of the file, as if the
    * source file had one more empty line at the end. This simplifies the binary
    * search in [getLine].
    */
-  set lineStarts(v) => lineStartsCache = v;
+  set lineStarts(List<int> v) => lineStartsCache = v;
 
   List<int> lineStartsCache;
 
   List<int> lineStartsFromString(String text) {
     var starts = [0];
     var index = 0;
     while (index < text.length) {
       index = text.indexOf('\n', index) + 1;
       if (index <= 0) break;
       starts.add(index);
@@ skipping 95 matching lines @@
     return slowText().substring(start, end);
   }
 
   int get length {
     if (lengthCache == -1) {
       // During scanning the length is not yet assigned, so we use a slow path.
       length = slowText().length;
     }
     return lengthCache;
   }
-  set length(v) => lengthCache = v;
+  set length(int v) => lengthCache = v;
   int lengthCache = -1;
 }
 
 class StringSourceFile extends SourceFile {
 
   final String text;
 
   StringSourceFile(String filename, this.text) : super(filename);
 
   int get length => text.length;
-  set length(v) { }
+  set length(int v) { }
 
   String slowText() => text;
 
   List<int> slowUtf8Bytes() => UTF8.encode(text);
 
   String slowSubstring(int start, int end) => text.substring(start, end);
 }