Scanner for UTF-8 byte arrays

tests/compiler/dart2js/cpa_inference_test.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.
 
 import 'dart:async';
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 import '../../../sdk/lib/_internal/compiler/implementation/source_file.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/types.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/types/concrete_types_inferrer.dart';
 
 import "parser_helper.dart";
 import "compiler_helper.dart";
 
 /**
  * Finds the node corresponding to the last occurence of the substring
  * [: identifier; :] in the program represented by the visited AST.
  */
 class VariableFinderVisitor extends Visitor {
   final String identifier;
   Node result;
 
   VariableFinderVisitor(this.identifier);
 
   visitSend(Send node) {
     if (node.isPropertyAccess
-        && node.selector.asIdentifier().source.slowToString() == identifier) {
+        && node.selector.asIdentifier().source == identifier) {
       result = node;
     } else {
       node.visitChildren(this);
     }
   }
 
   visitNode(Node node) {
     node.visitChildren(this);
   }
 }
@@ skipping 19 matching lines @@
     int = inferrer.baseTypes.intBaseType;
     double = inferrer.baseTypes.doubleBaseType;
     num = inferrer.baseTypes.numBaseType;
     bool = inferrer.baseTypes.boolBaseType;
     string = inferrer.baseTypes.stringBaseType;
     list = inferrer.baseTypes.listBaseType;
     growableList = inferrer.baseTypes.growableListBaseType;
     map = inferrer.baseTypes.mapBaseType;
     nullType = const NullBaseType();
     functionType = inferrer.baseTypes.functionBaseType;
-    Element mainElement = compiler.mainApp.find(buildSourceString('main'));
+    Element mainElement = compiler.mainApp.find('main');
     ast = mainElement.parseNode(compiler);
   }
 
   BaseType base(String className) {
-    final source = buildSourceString(className);
+    final source = className;
     return new ClassBaseType(compiler.mainApp.find(source));
   }
 
   /**
    * Finds the [Node] corresponding to the last occurence of the substring
    * [: identifier; :] in the program represented by the visited AST. For
    * instance, returns the AST node representing [: foo; :] in
    * [: main() { foo = 1; foo; } :].
    */
   Node findNode(String identifier) {
     VariableFinderVisitor finder = new VariableFinderVisitor(identifier);
     ast.accept(finder);
     return finder.result;
   }
 
   /**
    * Finds the [Element] corresponding to [: className#fieldName :].
    */
   Element findField(String className, String fieldName) {
-    ClassElement element = compiler.mainApp.find(buildSourceString(className));
-    return element.lookupLocalMember(buildSourceString(fieldName));
+    ClassElement element = compiler.mainApp.find(className);
+    return element.lookupLocalMember(fieldName);
   }
 
   ConcreteType concreteFrom(List<BaseType> baseTypes) {
     ConcreteType result = inferrer.emptyConcreteType;
     for (final baseType in baseTypes) {
       result = result.union(inferrer.singletonConcreteType(baseType));
     }
     // We make sure the concrete types expected by the tests don't default to
     // dynamic because of widening.
     assert(!result.isUnknown());
@@ skipping 71 matching lines @@
   class StackTrace {}
   class Dynamic_ {}
   bool identical(Object a, Object b) {}''';
 
 Future<AnalysisResult> analyze(String code, {int maxConcreteTypeSize: 1000}) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = new MockCompiler(
       coreSource: CORELIB,
       enableConcreteTypeInference: true,
       maxConcreteTypeSize: maxConcreteTypeSize);
-  compiler.sourceFiles[uri.toString()] = new SourceFile(uri.toString(), code);
+  compiler.sourceFiles[uri.toString()] =
+      new StringSourceFile(uri.toString(), code);
   compiler.typesTask.concreteTypesInferrer.testMode = true;
   return compiler.runCompiler(uri).then((_) {
     return new AnalysisResult(compiler);
   });
 }
 
 testDynamicBackDoor() {
   final String source = r"""
     main () {
       var x = "__dynamic_for_test";
@@ skipping 1338 matching lines @@
     ClassElement abc = findElement(result.compiler, 'ABC');
     ClassElement bc = findElement(result.compiler, 'BC');
     ClassElement a = findElement(result.compiler, 'A');
     ClassElement b = findElement(result.compiler, 'B');
     ClassElement c = findElement(result.compiler, 'C');
     ClassElement xy = findElement(result.compiler, 'XY');
     ClassElement x = findElement(result.compiler, 'X');
     ClassElement y = findElement(result.compiler, 'Y');
     ClassElement z = findElement(result.compiler, 'Z');
 
-    Selector foo = new Selector.call(buildSourceString("foo"), null, 0);
+    Selector foo = new Selector.call("foo", null, 0);
 
     Expect.equals(
         inferredType(foo).simplify(result.compiler),
         new TypeMask.nonNullSubclass(abc));
     Expect.equals(
         inferredType(new TypedSelector.subclass(x, foo)),
         new TypeMask.nonNullExact(b));
     Expect.equals(
         inferredType(new TypedSelector.subclass(y, foo)),
         new TypeMask.nonNullExact(c));
     Expect.equals(
         inferredType(new TypedSelector.subclass(z, foo)),
         new TypeMask.nonNullExact(a));
     Expect.equals(
         inferredType(new TypedSelector.subclass(
             xy, foo)).simplify(result.compiler),
         new TypeMask.nonNullSubclass(bc));
 
-    Selector bar = new Selector.call(buildSourceString("bar"), null, 0);
+    Selector bar = new Selector.call("bar", null, 0);
 
     Expect.isNull(inferredType(bar));
   });
 }
 
 testMixins() {
   final String source = r"""
       class A {
         foo() => "abc";
         get x => 42;
@@ skipping 126 matching lines @@
     testIsCheck,
     testSeenClasses,
     testIntDoubleNum,
     testConcreteTypeToTypeMask,
     testSelectors,
     testMixins,
     testClosures,
     testNestedFunctions,
   ], (f) => f()));
 }