Implement references to "this" in the new IR.

sdk/lib/_internal/compiler/implementation/ir/ir_builder.dart

 // Copyright (c) 2013, 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.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 792 matching lines @@
     return result;
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(isOpen);
     ir.Constant constant = new ir.Constant(getConstantForNode(node));
     add(new ir.LetPrim(constant));
     return constant;
   }
 
+  ir.Primitive visitIdentifier(ast.Identifier node) {
+    assert(isOpen);
+    assert(node.isThis());
+    return lookupThis();
+  }
+
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
   // Stores the result of visiting a CascadeReceiver, so we can return it from
   // its enclosing Cascade.
   ir.Primitive _currentCascadeReceiver;
 
   ir.Primitive visitCascadeReceiver(ast.CascadeReceiver node) {
     assert(isOpen);
     return _currentCascadeReceiver = visit(node.expression);
   }
 
   ir.Primitive visitCascade(ast.Cascade node) {
     assert(isOpen);
     var oldCascadeReceiver = _currentCascadeReceiver;
     // Throw away the result of visiting the expression.
     // Instead we return the result of visiting the CascadeReceiver.
     this.visit(node.expression);
     ir.Primitive receiver = _currentCascadeReceiver;
     _currentCascadeReceiver = oldCascadeReceiver;
     return receiver;
   }
 
+  ir.Primitive lookupThis() {
+    ir.Primitive result = new ir.This();
+    add(new ir.LetPrim(result));
+    return result;
+  }
+
   ir.Primitive lookupLocal(Element element) {
     int index = variableIndex[element];
     ir.Primitive value = assignedVars[index];
     return value == null ? freeVars[index] : value;
   }
 
   // ==== Sends ====
   ir.Primitive visitAssert(ast.Send node) {
     assert(isOpen);
     return giveup(node, 'Assert');
@@ skipping 51 matching lines @@
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       return lookupLocal(element);
     } else if (element == null || Elements.isInstanceField(element)) {
-      // TODO: Support implicit this.
-      if (node.receiver == null) return giveup(node);
-
-      ir.Primitive receiver = visit(node.receiver);
+      ir.Primitive receiver = node.receiver == null
+          ? lookupThis()
+          : visit(node.receiver);
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
       ir.InvokeMethod invoke = new ir.InvokeMethod(receiver, selector, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
     } else if (element.isField) {
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
@@ skipping 238 matching lines @@
         ir.InvokeStatic invoke =
             new ir.InvokeStatic(element, selector, k, [arg]);
         add(new ir.LetCont(k, invoke));
         return arg;
       } else if (node.receiver == null) {
         // Nodes that fall in this case:
         // - Unresolved top-level
         // - Assignment to final variable (will not be resolved)
         return giveup(node, 'SendSet: non-local, non-static, but no receiver');
       } else {
+        if (element != null && Elements.isUnresolved(element)) return giveup();
+
         // Setter or index-setter invocation
         assert(node.receiver != null);
+
         if (node.receiver.isSuper()) return giveup(node, 'Super SendSet');
 
-        ir.Primitive receiver = visit(node.receiver);
+        ir.Primitive receiver = node.receiver == null
+            ? lookupThis()
+            : visit(node.receiver);
         ir.Parameter v = new ir.Parameter(null);
         ir.Continuation k = new ir.Continuation([v]);
         Selector selector = elements.getSelector(node);
         assert(selector.kind == SelectorKind.SETTER ||
             selector.kind == SelectorKind.INDEX);
         List<ir.Definition> args = node.arguments.mapToList(visit,
                                                             growable:false);
         ir.InvokeMethod invoke =
             new ir.InvokeMethod(receiver, selector, k, args);
         add(new ir.LetCont(k, invoke));
@@ skipping 107 matching lines @@
       if (e == ABORT_IRNODE_BUILDER) return null;
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
     giveup(node);
   }
 }