Return null from stringValue and call slowToString() instead of toString().

dart/frog/leg/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 26 matching lines @@
     if (name === '>>=') return const SourceString('shr');
     if (name === '|=') return const SourceString('or');
     if (name === '&=') return const SourceString('and');
     if (name === '^=') return const SourceString('xor');
     if (name === '++') return const SourceString('add');
     if (name === '--') return const SourceString('sub');
     compiler.unimplemented('Unknown operator', node: op);
   }
 
   Element getStaticInterceptor(SourceString name, int parameters) {
-    String mangledName = "builtin\$${name}\$${parameters}";
+    String mangledName = "builtin\$${name.slowToString()}\$${parameters}";
     Element result = compiler.findHelper(new SourceString(mangledName));
     return result;
   }
 
   Element getStaticGetInterceptor(SourceString name) {
-    String mangledName = "builtin\$get\$${name}";
+    String mangledName = "builtin\$get\$${name.slowToString()}";
     Element result = compiler.findHelper(new SourceString(mangledName));
     return result;
   }
 
   Element getStaticSetInterceptor(SourceString name) {
-    String mangledName = "builtin\$set\$${name}";
+    String mangledName = "builtin\$set\$${name.slowToString()}";
     Element result = compiler.findHelper(new SourceString(mangledName));
     return result;
   }
 
   Element getOperatorInterceptor(Operator op) {
     SourceString name = mapOperatorToMethodName(op);
     Element result = compiler.findHelper(name);
     return result;
   }
 
@@ skipping 1119 matching lines @@
       // with the set of locals we got after visiting the then
       // part of the if.
       open(joinBlock);
       if (joinBlock.predecessors.length == 2) {
         localsHandler.mergeWith(thenLocals, joinBlock);
       }
     }
   }
 
   SourceString unquote(LiteralString literal, int start) {
-    String str = '${literal.value}';
+    String str = '${literal.value.slowToString()}';
     int quotes = 1;
     String quote = str[start];
     while (str[quotes + start] === quote) quotes++;
     return new SourceString(str.substring(quotes + start, str.length - quotes));
   }
 
   void visitLogicalAndOr(Send node, Operator op) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) t1 = boolify(y);
@@ skipping 445 matching lines @@
       closureTarget = localsHandler.readLocal(element);
     }
     var inputs = <HInstruction>[];
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     push(new HInvokeClosure(selector, inputs));
   }
 
   visitForeignSend(Send node) {
     Identifier selector = node.selector;
-    switch (selector.source.stringValue) {
+    switch (selector.source.slowToString()) {
       case "JS":
         Link<Node> link = node.arguments;
         // If the invoke is on foreign code, don't visit the first
         // argument, which is the type, and the second argument,
         // which is the foreign code.
         link = link.tail.tail;
         List<HInstruction> inputs = <HInstruction>[];
         addGenericSendArgumentsToList(link, inputs);
         LiteralString type = node.arguments.head;
         LiteralString literal = node.arguments.tail.head;
         compiler.ensure(literal is LiteralString);
         compiler.ensure(type is LiteralString);
-        compiler.ensure(literal.value.stringValue[0] == '@');
+        compiler.ensure(literal.value.slowToString()[0] == '@');
         push(new HForeign(unquote(literal, 1), unquote(type, 0), inputs));
         break;
       case "UNINTERCEPTED":
         Link<Node> link = node.arguments;
         if (!link.tail.isEmpty()) {
           compiler.cancel('More than one expression in UNINTERCEPTED()');
         }
         Expression expression = link.head;
         disableMethodInterception();
         visit(expression);
@@ skipping 601 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }