Refactor index operator in SimpleTypeInferrer.

tests/compiler/dart2js/semantic_visitor_test.dart

 // Copyright (c) 2015, 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.semantics_visitor_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 1232 matching lines @@
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_INDEX_PREFIX,
                     getter: 'function(B#[])',
                     setter: 'function(B#[]=)',
                     index: '42',
                     operator: '++')),
     const Test.clazz(
         '''
         class B {
+          operator []=(a, b) {}
+        }
+        class C extends B {
+          m() => ++super[42];
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
+                    index: '42',
+                    operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => ++super[42];
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
+                    index: '42',
+                    operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          operator [](_) => null;
+        }
+        class C extends B {
+          m() => ++super[42];
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_PREFIX,
+                    getter: 'function(B#[])',
+                    index: '42',
+                    operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
           operator [](_) => null;
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[42]--;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_INDEX_POSTFIX,
                     getter: 'function(B#[])',
                     setter: 'function(B#[]=)',
                     index: '42',
                     operator: '--')),
+    const Test.clazz(
+        '''
+        class B {
+          operator []=(a, b) {}
+        }
+        class C extends B {
+          m() => super[42]--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
+                    index: '42',
+                    operator: '--')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => super[42]--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
+                    index: '42',
+                    operator: '--')),
+    const Test.clazz(
+        '''
+        class B {
+          operator [](_) => null;
+        }
+        class C extends B {
+          m() => super[42]--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX,
+                    getter: 'function(B#[])',
+                    index: '42',
+                    operator: '--')),
   ],
   'Equals': const [
     // Equals
     const Test(
         '''
         m() => 2 == 3;
         ''',
         const Visit(VisitKind.VISIT_EQUALS,
                     left: '2', right: '3')),
     const Test.clazz(
@@ skipping 95 matching lines @@
         '''
         class B {
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[1] = 2;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_INDEX_SET,
             element: 'function(B#[]=)', index: '1', rhs: '2')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => super[1] = 2;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_SET,
+            index: '1', rhs: '2')),
   ],
   'Compound assignment': const [
     // Compound assignment
     const Test(
         '''
         m(a) => a.b += 42;
         ''',
         const [
           const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_COMPOUND,
               receiver: 'a', operator: '+=', rhs: '42',
@@ skipping 308 matching lines @@
             operator: '+=', rhs: '42')),*/
   ],
   'Compound index assignment': const [
     // Compound index assignment
     const Test(
         '''
         m() => 0[1] += 42;
         ''',
         const Visit(VisitKind.VISIT_COMPOUND_INDEX_SET,
             receiver: '0', index: '1', operator: '+=', rhs: '42')),
-    // TODO(johnniwinther): Enable this when the getter element is stored.
-    /*const Test.clazz(
+    const Test.clazz(
         '''
         class B {
           operator [](_) {}
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[1] += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_COMPOUND_INDEX_SET,
             getter: 'function(B#[])', setter: 'function(B#[]=)',
-            index: '1', operator: '+=', rhs: '42')),*/
+            index: '1', operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+          operator []=(a, b) {}
+        }
+        class C extends B {
+          m() => super[1] += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
+            index: '1', operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => super[1] += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
+            index: '1', operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+          operator [](_) {}
+        }
+        class C extends B {
+          m() => super[1] += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET,
+            getter: 'function(B#[])',
+            index: '1', operator: '+=', rhs: '42')),
   ],
   'Prefix expression': const [
     // Prefix expression
     const Test(
         '''
         m(a) => --a.b;
         ''',
         const [
           const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_PREFIX,
               receiver: 'a', operator: '--',
@@ skipping 3445 matching lines @@
   @override
   errorUndefinedUnaryExpression(
       Send node,
       Operator operator,
       Node expression,
       arg) {
     // TODO: implement errorUndefinedUnaryExpression
   }
 
   @override
-  errorUnresolvedSuperCompoundIndexSet(
+  visitUnresolvedSuperGetterCompoundIndexSet(
       Send node,
-      ErroneousElement element,
+      Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorUnresolvedSuperCompoundIndexSet
+    visits.add(new Visit(
+        VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
+        index: index, operator: operator, rhs: rhs));
+    apply(index, arg);
+    apply(rhs, arg);
   }
 
   @override
-  errorUnresolvedSuperIndexSet(
+  visitUnresolvedSuperSetterCompoundIndexSet(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET,
+        getter: getter, index: index, operator: operator, rhs: rhs));
+    apply(index, arg);
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedSuperIndexSet(
       Send node,
       ErroneousElement element,
       Node index,
       Node rhs,
       arg) {
-    // TODO: implement errorUnresolvedSuperIndexSet
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_SET,
+               index: index, rhs: rhs));
+    apply(index, arg);
+    apply(rhs, arg);
   }
 
   @override
-  errorUnresolvedSuperIndexPostfix(
+  visitUnresolvedSuperGetterIndexPostfix(
       Send node,
-      Element function,
+      Element element,
       Node index,
       IncDecOperator operator,
       arg) {
-    // TODO: implement errorUnresolvedSuperIndexPostfix
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
+               index: index, operator: operator));
+    apply(index, arg);
   }
 
   @override
-  errorUnresolvedSuperIndexPrefix(
+  visitUnresolvedSuperSetterIndexPostfix(
       Send node,
-      Element function,
+      MethodElement getter,
+      Element element,
       Node index,
       IncDecOperator operator,
       arg) {
-    // TODO: implement errorUnresolvedSuperIndexPrefix
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX,
+               getter: getter, index: index, operator: operator));
+    apply(index, arg);
   }
 
   @override
+  visitUnresolvedSuperGetterIndexPrefix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,

[karlklose, 2015/05/11 10:38:56]

Consider adding a helper for 'visits.add(new Visit(....));'.

[Johnni Winther, 2015/05/11 13:04:29]

Acknowledged.

+               index: index, operator: operator));
+    apply(index, arg);
+  }
+
+  @override
+  visitUnresolvedSuperSetterIndexPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_PREFIX,
+               getter: getter, index: index, operator: operator));
+    apply(index, arg);
+  }
+
+  @override
   visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_INDEX_POSTFIX,
         receiver: receiver, index: index, operator: operator));
     apply(receiver, arg);
     apply(index, arg);
@@ skipping 931 matching lines @@
   VISIT_INDEX_PREFIX,
   VISIT_INDEX_POSTFIX,
 
   VISIT_SUPER_BINARY,
   VISIT_UNRESOLVED_SUPER_BINARY,
   VISIT_SUPER_INDEX,
   VISIT_UNRESOLVED_SUPER_INDEX,
   VISIT_SUPER_EQUALS,
   VISIT_SUPER_NOT_EQUALS,
   VISIT_SUPER_INDEX_PREFIX,
+  VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
+  VISIT_UNRESOLVED_SUPER_SETTER_INDEX_PREFIX,
   VISIT_SUPER_INDEX_POSTFIX,
+  VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
+  VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX,
 
   VISIT_UNARY,
   VISIT_SUPER_UNARY,
   VISIT_UNRESOLVED_SUPER_UNARY,
   VISIT_NOT,
 
   VISIT_EXPRESSION_INVOKE,
 
   VISIT_CLASS_TYPE_LITERAL_GET,
   VISIT_CLASS_TYPE_LITERAL_SET,
@@ skipping 23 matching lines @@
   VISIT_DYNAMIC_TYPE_LITERAL_SET,
   VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
   VISIT_DYNAMIC_TYPE_LITERAL_BINARY,
   ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
   ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
   ERROR_DYNAMIC_TYPE_LITERAL_POSTFIX,
 
   VISIT_INDEX_SET,
   VISIT_COMPOUND_INDEX_SET,
   VISIT_SUPER_INDEX_SET,
+  VISIT_UNRESOLVED_SUPER_INDEX_SET,
   VISIT_SUPER_COMPOUND_INDEX_SET,
+  VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
+  VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET,
 
   VISIT_ASSERT,
   VISIT_LOGICAL_AND,
   VISIT_LOGICAL_OR,
   VISIT_IS,
   VISIT_IS_NOT,
   VISIT_AS,
 
   VISIT_CONST_CONSTRUCTOR_INVOKE,
   VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
@@ skipping 27 matching lines @@
   VISIT_OPTIONAL_PARAMETER_DECL,
   VISIT_NAMED_PARAMETER_DECL,
   VISIT_REQUIRED_INITIALIZING_FORMAL_DECL,
   VISIT_OPTIONAL_INITIALIZING_FORMAL_DECL,
   VISIT_NAMED_INITIALIZING_FORMAL_DECL,
 
   ERROR_UNRESOLVED_POSTFIX,
 
   // TODO(johnniwinther): Add tests for more error cases.
 }