dart2js: Handle zero-terminated content explicitly.

pkg/compiler/lib/src/io/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 dart2js.io.source_file;
 
 import 'dart:math';
 import 'dart:convert' show UTF8;
+import 'dart:typed_data' show Uint8List;
 
 import 'line_column_provider.dart';
 
 /**
  * Represents a file of source code. The content can be either a [String] or
  * a UTF-8 encoded [List<int>] of bytes.
  */
 abstract class SourceFile implements LineColumnProvider {
   /// The absolute URI of the source file.
   Uri get uri;
 
   /// The name of the file.
   ///
   /// This is [uri], maybe relativized to a more human-readable form.
   String get filename => uri.toString();
 
   /** The text content of the file represented as a String. */
   String slowText();
 
-  /** The content of the file represented as a UTF-8 encoded [List<int>]. */
-  List<int> slowUtf8Bytes();
+  /**
+   * The content of the file represented as a UTF-8 encoded [List<int>],
+   * terminated with a trailing 0 byte.
+   */
+  List<int> slowUtf8ZeroTerminatedBytes();
 
   /**
    * 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.
@@ skipping 121 matching lines @@
 
       for (; i < toColumn; i++) {
         buf.write(colorize('^'));
       }
     }
 
     return buf.toString();
   }
 }
 
+List<int> _zeroTerminateIfNecessary(List<int> bytes) {
+  if (bytes.length > 0 && bytes.last == 0) return bytes;
+  List<int> result = new Uint8List(bytes.length + 1);
+  result.setRange(0, bytes.length, bytes);
+  result[result.length - 1] = 0;
+  return result;
+}
+
 class Utf8BytesSourceFile extends SourceFile {
   final Uri uri;
 
   /** The UTF-8 encoded content of the source file. */
-  final List<int> content;
+  final List<int> zeroTerminatedContent;
 
-  Utf8BytesSourceFile(this.uri, this.content);
+  /**
+   * Creates a Utf8BytesSourceFile.
+   *
+   * If possible, the given [content] should be zero-terminated. If it isn't,
+   * the constructor clones the content and adds a trailing 0.
+   */
+  Utf8BytesSourceFile(this.uri, List<int> content)
+    : this.zeroTerminatedContent = _zeroTerminateIfNecessary(content);
 
-  String slowText() => UTF8.decode(content);
+  String slowText() {
+    // Don't convert the trailing zero byte.
+    return UTF8.decoder.convert(
+        zeroTerminatedContent, 0, zeroTerminatedContent.length - 1);
+  }
 
-  List<int> slowUtf8Bytes() => content;
+  List<int> slowUtf8ZeroTerminatedBytes() => zeroTerminatedContent;
 
   String slowSubstring(int start, int end) {
     // TODO(lry): to make this faster, the scanner could record the UTF-8 slack
     // for all positions of the source text. We could use [:content.sublist:].
     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.
@@ skipping 31 matching lines @@
       : this(uri, uri.toString(), text);
 
   StringSourceFile.fromName(String filename, String text)
       : this(new Uri(path: filename), filename, text);
 
   int get length => text.length;
   set length(int v) { }
 
   String slowText() => text;
 
-  List<int> slowUtf8Bytes() => UTF8.encode(text);
+  List<int> slowUtf8ZeroTerminatedBytes() {
+    return _zeroTerminateIfNecessary(UTF8.encode(text));
+  }
 
   String slowSubstring(int start, int end) => text.substring(start, end);
 }