Make sure to register +/- when we're using ++/--.

tests/compiler/dart2js/resolver_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:uri');
 
 #import("../../../lib/compiler/implementation/leg.dart");
 #import("../../../lib/compiler/implementation/elements/elements.dart");
 #import("../../../lib/compiler/implementation/tree/tree.dart");
 #import("../../../lib/compiler/implementation/scanner/scannerlib.dart");
@@ skipping 57 matching lines @@
   testFunctionExpression();
   testNewExpression();
   testTopLevelFields();
   testClassHierarchy();
   testInitializers();
   testThis();
   testSuperCalls();
   testTypeVariables();
   testToString();
   testIndexedOperator();
+  testIncrementsAndDecrements();
 }
 
 testTypeVariables() {
   matchResolvedTypes(visitor, text, name, expectedElements) {
     VariableDefinitions definition = parseStatement(text);
     visitor.visit(definition.type);
     InterfaceType type = visitor.mapping.getType(definition.type);
     Expect.equals(definition.type.typeArguments.length(),
                   length(type.arguments));
     int index = 0;
@@ skipping 640 matching lines @@
   return result;
 }
 
 compileScript(String source) {
   Uri uri = new Uri.fromComponents(scheme: 'source');
   MockCompiler compiler = compilerFor(source, uri);
   compiler.runCompiler(uri);
   return compiler;
 }
 
+checkMemberResolved(compiler, className, memberName) {
+  Element memberElement = findElement(compiler, className)
+      .lookupLocalMember(memberName);
+  Expect.isNotNull(memberElement);
+  Expect.isNotNull(
+      compiler.enqueuer.resolution.getCachedElements(memberElement));
+}
+
 testToString() {
   final script = @"class C { toString() => 'C'; } main() { '${new C()}'; }";
   final compiler = compileScript(script);
 
-  Element toStringMethod = findElement(compiler, 'C')
-      .lookupLocalMember(buildSourceString('toString'));
-  Expect.isNotNull(toStringMethod);
+  checkMemberResolved(compiler, 'C', buildSourceString('toString'));
+}
 
-  Expect.isNotNull(
-      compiler.enqueuer.resolution.getCachedElements(toStringMethod));
-}
+operatorName(op) => Elements.constructOperatorName(
+    const SourceString('operator'), new SourceString(op));
 
 testIndexedOperator() {
   final script = @"""
       class C {
         operator[](ix) => ix;
         operator[]=(ix, v) {}
       }
-      main() { var c = new C(); c[0]++ ; }""";
+      main() { var c = new C(); c[0]++; }""";
   final compiler = compileScript(script);
 
-  operatorName(op) => Elements.constructOperatorName(
-      const SourceString('operator'), new SourceString(op));
+  checkMemberResolved(compiler, 'C', operatorName('[]'));
+  checkMemberResolved(compiler, 'C', operatorName('[]='));
+}
 
-  Element indexedOperator = findElement(compiler, 'C')
-      .lookupLocalMember(operatorName('[]'));
-  Expect.isNotNull(indexedOperator);
-  Expect.isNotNull(
-      compiler.enqueuer.resolution.getCachedElements(indexedOperator));
+testIncrementsAndDecrements() {
+  final script = @"""
+      class A { operator+(o)=>null; }
+      class B { operator+(o)=>null; }
+      class C { operator-(o)=>null; }
+      class D { operator-(o)=>null; }
+      main() {
+        var a = new A();
+        a++;
+        var b = new B();
+        ++b;
+        var c = new C();
+        c--;
+        var d = new D();
+        --d;
+      }""";
+  final compiler = compileScript(script);
 
-  Element indexedSetOperator = findElement(compiler, 'C')
-      .lookupLocalMember(operatorName('[]='));
-  Expect.isNotNull(indexedOperator);
-  Expect.isNotNull(
-      compiler.enqueuer.resolution.getCachedElements(indexedSetOperator));
+  checkMemberResolved(compiler, 'A', operatorName('+'));
+  checkMemberResolved(compiler, 'B', operatorName('+'));
+  checkMemberResolved(compiler, 'C', operatorName('-'));
+  checkMemberResolved(compiler, 'D', operatorName('-'));
 }