Start new design for interceptors and implement String.charCodeAt with it.

sdk/lib/_internal/compiler/implementation/ssa/variable_allocator.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.
 
 part of ssa;
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
@@ skipping 423 matching lines @@
         copyHandlers.putIfAbsent(block, () => new CopyHandler());
     handler.addAssignment(source, destination);
   }
 }
 
 /**
  * Allocates variable names for instructions, making sure they don't collide.
  */
 class VariableNamer {
   final VariableNames names;
+  final Compiler compiler;
   final Set<String> usedNames;
   final Map<Element, String> parameterNames;
   final List<String> freeTemporaryNames;
   int temporaryIndex = 0;
 
-  VariableNamer(LiveEnvironment environment, this.names, this.parameterNames)
+  VariableNamer(LiveEnvironment environment,
+                this.names,
+                this.parameterNames,
+                this.compiler)
     : usedNames = new Set<String>(),
       freeTemporaryNames = new List<String>() {
     // [VariableNames.swapTemp] is used when there is a cycle in a copy handler.
     // Therefore we make sure no one uses it.
     usedNames.add(names.swapTemp);
     // [VariableNames.stateName] is being used throughout a bailout function.
     // Whenever a bailout-target is reached we set the state-variable to 0. We
     // must therefore not have any local variable that could clash with the
     // state variable.
     // Therefore we make sure no one uses it at any time.
@@ skipping 44 matching lines @@
       // Special case this instruction to use the name of its
       // input if it has one.
       var temp = instruction;
       do {
         temp = temp.checkedInput;
         name = names.ownName[temp];
       } while (name == null && temp is HCheck);
       if (name != null) return addAllocatedName(instruction, name);
     }
 
-    // The dom/html libraries have inline JS code that reference        
-    // parameter names directly. Long-term such code will be rejected.
-    // Now, just don't mangle the parameter name.
-    if (instruction is HParameterValue
+    if (instruction is HThis) {
+      name = "this";
+      if (instruction.sourceElement != null) {
+        Element cls = instruction.sourceElement.getEnclosingClass();
+        // Change the name of [:this:] in a method of a foreign class
+        // to use the first parameter of the method, which is the
+        // actual receiver.
+        if (compiler.isForeignClass(cls)) {
+          name = "primitive";
+        }
+      }
+    } else if (instruction is HParameterValue
         && instruction.sourceElement.enclosingElement.isNative()) {
+      // The dom/html libraries have inline JS code that reference      
+      // parameter names directly. Long-term such code will be rejected.
+      // Now, just don't mangle the parameter name.
       name = instruction.sourceElement.name.slowToString();
     } else if (instruction.sourceElement != null) {
       name = allocateWithHint(instruction.sourceElement.name.slowToString());
     } else {
       // We could not find an element for the instruction. If the
       // instruction is used by a phi, try to use the name of the phi.
       // Otherwise, just allocate a temporary name.
       HPhi phi = firstPhiUserWithElement(instruction);
       if (phi != null) {
         name = allocateWithHint(phi.sourceElement.name.slowToString());
       } else {
         name = allocateTemporary();
       }
     }
-
     return addAllocatedName(instruction, name);
   }
 
   String addAllocatedName(HInstruction instruction, String name) {
-    if (instruction is HParameterValue) {
+    if (instruction is HParameterValue && name != 'this') {
       parameterNames[instruction.sourceElement] = name;
     }
     usedNames.add(name);
     names.addNameUsed(name);
     names.ownName[instruction] = name;
     return name;
   }
 
   /**
    * Frees [instruction]'s name so it can be used for other instructions.
@@ skipping 43 matching lines @@
                        parameterNames)
     : this.names = new VariableNames(parameterNames),
       this.parameterNames = parameterNames;
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     VariableNamer namer = new VariableNamer(
-        liveInstructions[block], names, parameterNames);
+        liveInstructions[block], names, parameterNames, compiler);
 
     block.forEachPhi((HPhi phi) {
       handlePhi(phi, namer);
     });
 
     block.forEachInstruction((HInstruction instruction) {
       handleInstruction(instruction, namer);
     });
   }
 
   /**
    * Returns whether [instruction] needs a name. Instructions that
    * have no users or that are generated at use site does not need a name.
    */
   bool needsName(HInstruction instruction) {
     // TODO(ngeoffray): locals/parameters are being generated at use site,
     // but we need a name for them. We should probably not make
     // them generate at use site to make things simpler.
-    if (instruction is HLocalValue && instruction is !HThis) return true;
+    if (instruction is HLocalValue) return true;
     if (instruction.usedBy.isEmpty) return false;
     if (generateAtUseSite.contains(instruction)) return false;
     // A [HCheck] instruction that has control flow needs a name only if its
     // checked input needs a name (e.g. a check [HConstant] does not
     // need a name).
     if (instruction is HCheck && instruction.isControlFlow()) {
       HCheck check = instruction;
       return needsName(instruction.checkedInput);
     }
     return true;
@@ skipping 43 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }