Infer SendSet node correctly.

tests/compiler/dart2js/simple_inferrer_postfix_prefix_test.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.
 
 import 'compiler_helper.dart';
+import 'parser_helper.dart';
 
 const String TEST = """
-returnNum1(a) {
-  if (a) return 1;
-  else return 2.0;
+
+class A {
+  get foo => 'string';
+  set foo(value) {}
+  operator[](index) => 'string';
+  operator[]=(index, value) {}
+  
+  returnString1() => foo--;
+  returnNum1() => --foo;
+  returnNum2() => foo -= 42;
+
+  returnDynamic1() => this[index]--;
+  returnNum3() => --this[index];
+  returnNum4() => this[index] -= 42;
+
+  returnDynamic2() => this.bar--;
+  returnNum5() => --this.bar;
+  returnNum6() => this.bar -= 42;
 }
 
-returnNum2(a) {
-  if (a) return 1.0;
-  else return 2;
-}
+class B extends A {
+  returnString1() => super.foo--;
+  returnNum1() => --super.foo;
+  returnNum2() => super.foo -= 42;
 
-returnInt(a) {
-  if (a) return 1;
-  else return 2;
-}
-
-returnDouble(a) {
-  if (a) return 1.0;
-  else return 2.0;
-}
-
-returnGiveUp(a) {
-  if (a) return 1;
-  else return 'foo';
+  returnDynamic1() => super[index]--;
+  returnNum3() => --super[index];
+  returnNum4() => super[index] -= 42;
 }
 
 main() {
-  returnNum1(true);
-  returnNum2(true);
-  returnInt(true);
-  returnDouble(true);
-  returnGiveUp(true);
+  new A()..returnNum1()
+         ..returnNum2()
+         ..returnNum3()
+         ..returnNum4()
+         ..returnNum5()
+         ..returnNum6()
+         ..returnString1()
+         ..returnDynamic1()
+         ..returnDynamic2();
+
+  new B()..returnNum1()
+         ..returnNum2()
+         ..returnNum3()
+         ..returnNum4()
+         ..returnString1()
+         ..returnDynamic1();
 }
 """;
 
 void main() {
   Uri uri = new Uri.fromComponents(scheme: 'source');
   var compiler = compilerFor(TEST, uri);
   compiler.runCompiler(uri);
   var typesInferrer = compiler.typesTask.typesInferrer;
 
-  var element = findElement(compiler, 'returnNum1');
-  Expect.equals(compiler.numClass, typesInferrer.returnTypeOf[element]);
+  checkReturnInClass(String className, String methodName, type) {
+    var cls = findElement(compiler, className);
+    var element = cls.lookupLocalMember(buildSourceString(methodName));
+    Expect.equals(type, typesInferrer.returnTypeOf[element]);
+  }
 
-  element = findElement(compiler, 'returnNum2');
-  Expect.equals(compiler.numClass, typesInferrer.returnTypeOf[element]);
+  checkReturnInClass('A', 'returnNum1', compiler.numClass);
+  checkReturnInClass('A', 'returnNum2', compiler.numClass);
+  checkReturnInClass('A', 'returnNum3', compiler.numClass);
+  checkReturnInClass('A', 'returnNum4', compiler.numClass);
+  checkReturnInClass('A', 'returnNum5', compiler.numClass);
+  checkReturnInClass('A', 'returnNum6', compiler.numClass);
+  checkReturnInClass('A', 'returnDynamic1', compiler.dynamicClass);
+  checkReturnInClass('A', 'returnDynamic2', compiler.dynamicClass);
+  checkReturnInClass('A', 'returnString1', compiler.stringClass);
 
-  element = findElement(compiler, 'returnInt');
-  Expect.equals(compiler.intClass, typesInferrer.returnTypeOf[element]);
-
-  element = findElement(compiler, 'returnDouble');
-  Expect.equals(compiler.doubleClass, typesInferrer.returnTypeOf[element]);
-
-  element = findElement(compiler, 'returnGiveUp');
-  Expect.equals(typesInferrer.giveUpType, typesInferrer.returnTypeOf[element]);
+  checkReturnInClass('B', 'returnNum1', compiler.numClass);
+  checkReturnInClass('B', 'returnNum2', compiler.numClass);
+  checkReturnInClass('B', 'returnNum3', compiler.numClass);
+  checkReturnInClass('B', 'returnNum4', compiler.numClass);
+  checkReturnInClass('B', 'returnString1', compiler.stringClass);
+  checkReturnInClass('B', 'returnDynamic1', compiler.dynamicClass);
 }