Redo "Use an explicit 'this' parameter instead of 'This' nodes."

tests/compiler/dart2js/backend_dart/sexpr_unstringifier.dart

 // Copyright (c) 2014, 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.
 
 // SExpressionUnstringifier implements the inverse operation to
 // [SExpressionStringifier].
 
 library sexpr_unstringifier;
 
 import 'package:compiler/src/constants/expressions.dart'
@@ skipping 69 matching lines @@
   final List<String> _list;
   int _index; // Current index into the list.
 
   Tokens(List<String> this._list) : _index = 0;
 
   String get current => _list[_index];
   String get next    => _list[_index + 1];
 
   String read([String expected]) {
     if (expected != null) {
-      assert(current == expected);
+      if (current != expected) {
+        print('expected "$expected", found "$current"');
+        int start = _index - 15;
+        String dotdotdot = '... ';
+        if (start < 0) {
+          start = 0;
+          dotdotdot = '';
+        }
+        print('${dotdotdot}${_list.sublist(start, _index + 1).join(' ')}');
+        assert(current == expected);
+      }
     }
     return _list[_index++];
   }
 
   /// Consumes the preamble to a new node, consisting of an opening parenthesis
   /// and a tag.
   void consumeStart([String tag]) {
     read("(");
     if (tag != null) {
       read(tag);
@@ skipping 160 matching lines @@
   FunctionDefinition parseFunctionDefinition() {
     tokens.consumeStart(FUNCTION_DEFINITION);
 
     // name
     Element element = new DummyElement("");
     if (tokens.current != '(') {
       // This is a named function.
       element = new DummyElement(tokens.read());
     }
 
+    // (this) or ()
+    Definition thisParameter = null;
+    tokens.consumeStart();
+    if (tokens.current != ')') {
+      String thisName = tokens.read();
+      if (name2variable.containsKey(thisName)) {
+        thisParameter = name2variable[thisName];
+      } else {
+        thisParameter = new Parameter(new DummyElement(thisName));
+        name2variable[thisName] = thisParameter;
+      }
+    }
+    tokens.consumeEnd();
+
     // (parameters)
     List<Definition> parameters = <Definition>[];
     tokens.consumeStart();
     while (tokens.current != ")") {
       String paramName = tokens.read();
       if (name2variable.containsKey(paramName)) {
         parameters.add(name2variable[paramName]);
       } else {
         Parameter param = new Parameter(new DummyElement(paramName));
         name2variable[paramName] = param;
         parameters.add(param);
       }
     }
     tokens.consumeEnd();
 
     // continuation
     String contName = tokens.read("return");
     Continuation cont = name2variable[contName];
     assert(cont != null);
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
-    return new FunctionDefinition(element, parameters,
+    return new FunctionDefinition(element, thisParameter, parameters,
         new RunnableBody(body, cont), null, null);
   }
 
   /// (IsTrue arg)
   Condition parseCondition() {
     // Handles IsTrue only for now.
     tokens.consumeStart(IS_TRUE);
 
     Definition value = name2variable[tokens.read()];
     assert(value != null);
@@ skipping 399 matching lines @@
     return new ReifyTypeVar(type);
   }
 
   /// (This)
   This parseThis() {
     tokens.consumeStart(THIS);
     tokens.consumeEnd();
     return new This();
   }
 }