Revert "Change TypeInference to handle super calls as direct invocations." and "Optimize needNoSuch…

pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart

Index: pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
diff --git a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
index 7aba1204e3a0cc72a2c71fd221d161d0786c027f..f56483d6ec0b1687ad8d0bc80afe4c9a6e0a986f 100644
--- a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
@@ -6,7 +6,7 @@ library simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap;
 import '../common.dart';
-import '../common/names.dart' show Identifiers, Selectors;
+import '../common/names.dart' show Selectors;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart' show ConstantValue, IntConstantValue;
 import '../core_types.dart' show CoreClasses, CoreTypes;
@@ -878,66 +878,23 @@ class SimpleTypeInferrerVisitor<T>
   T visitSuperIndexPrefix(ast.Send node, MethodElement getter,
       MethodElement setter, ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, getter, setter, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
   T visitSuperIndexPostfix(ast.Send node, MethodElement getter,
       MethodElement setter, ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, getter, setter, indexType);
-  }
-
-  /// Handle compound prefix/postfix operations, like `super[0]++`.
-  T handleSuperIndexPrefixPostfix(
-      ast.Send node, Element getter, Element setter, T indexType) {
-    return _handleSuperCompoundIndexSet(
-        node, getter, setter, indexType, types.uint31Type);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   /// Handle compound super index set, like `super[42] =+ 2`.
-  T handleSuperCompoundIndexSet(ast.SendSet node, Element getter,
-      Element setter, ast.Node index, ast.Node rhs) {
+  T handleSuperCompoundIndexSet(
+      ast.SendSet node, ast.Node index, ast.Node rhs) {
+    T receiverType = superType;
     T indexType = visit(index);
     T rhsType = visit(rhs);
-    return _handleSuperCompoundIndexSet(
-        node, getter, setter, indexType, rhsType);
-  }
-
-  T _handleSuperCompoundIndexSet(ast.SendSet node, Element getter,
-      Element setter, T indexType, T rhsType) {
-    Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = elements.getGetterTypeMaskInComplexSendSet(node);
-    Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
-
-    T getterType = handleSuperSend(node, getterSelector, getterMask, getter,
-        new ArgumentsTypes<T>([indexType], null));
-
-    T returnType;
-    if (node.isIfNullAssignment) {
-      returnType = types.allocateDiamondPhi(getterType, rhsType);
-    } else {
-      Selector operatorSelector =
-          elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask =
-          elements.getOperatorTypeMaskInComplexSendSet(node);
-      returnType = handleDynamicSend(node, operatorSelector, operatorMask,
-          getterType, new ArgumentsTypes<T>([rhsType], null));
-    }
-    handleSuperSend(node, setterSelector, setterMask, setter,
-        new ArgumentsTypes<T>([indexType, returnType], null));
-
-    return node.isPostfix ? getterType : returnType;
-  }
-
-  T handleSuperSend(ast.Node node, Selector selector, TypeMask mask,
-      Element element, ArgumentsTypes arguments) {
-    if (element.isMalformed) {
-      return handleSuperNoSuchMethod(node, selector, mask, arguments);
-    } else {
-      return handleStaticSend(node, selector, mask, element, arguments);
-    }
+    return handleCompoundIndexSet(node, receiverType, indexType, rhsType);
   }
 
   @override
@@ -949,25 +906,25 @@ class SimpleTypeInferrerVisitor<T>
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
-    return handleSuperCompoundIndexSet(node, getter, setter, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitSuperIndexSetIfNull(ast.SendSet node, MethodElement getter,
       MethodElement setter, ast.Node index, ast.Node rhs, _) {
-    return handleSuperCompoundIndexSet(node, getter, setter, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperCompoundIndexSet(ast.Send node, Element element,
       ast.Node index, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompoundIndexSet(node, element, element, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperIndexSetIfNull(
       ast.Send node, Element element, ast.Node index, ast.Node rhs, _) {
-    return handleSuperCompoundIndexSet(node, element, element, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
@@ -979,13 +936,13 @@ class SimpleTypeInferrerVisitor<T>
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
-    return handleSuperCompoundIndexSet(node, element, setter, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperGetterIndexSetIfNull(ast.SendSet node, Element element,
       MethodElement setter, ast.Node index, ast.Node rhs, _) {
-    return handleSuperCompoundIndexSet(node, element, setter, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
@@ -997,27 +954,27 @@ class SimpleTypeInferrerVisitor<T>
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
-    return handleSuperCompoundIndexSet(node, getter, element, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperSetterIndexSetIfNull(ast.SendSet node,
       MethodElement getter, Element element, ast.Node index, ast.Node rhs, _) {
-    return handleSuperCompoundIndexSet(node, getter, element, index, rhs);
+    return handleSuperCompoundIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperIndexPrefix(ast.Send node, Element element,
       ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, element, element, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
   T visitUnresolvedSuperGetterIndexPrefix(ast.SendSet node, Element element,
       MethodElement setter, ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, element, setter, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
@@ -1029,21 +986,21 @@ class SimpleTypeInferrerVisitor<T>
       op.IncDecOperator operator,
       _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, getter, element, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
   T visitUnresolvedSuperIndexPostfix(ast.Send node, Element element,
       ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, element, element, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
   T visitUnresolvedSuperGetterIndexPostfix(ast.SendSet node, Element element,
       MethodElement setter, ast.Node index, op.IncDecOperator operator, _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, element, setter, indexType);
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   @override
@@ -1055,242 +1012,7 @@ class SimpleTypeInferrerVisitor<T>
       op.IncDecOperator operator,
       _) {
     T indexType = visit(index);
-    return handleSuperIndexPrefixPostfix(node, getter, element, indexType);
-  }
-
-  @override
-  T visitSuperFieldCompound(ast.Send node, FieldElement field,
-      op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, field, field, rhs);
-  }
-
-  @override
-  T visitSuperFieldSetterCompound(ast.Send node, FieldElement field,
-      FunctionElement setter, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, field, setter, rhs);
-  }
-
-  @override
-  T visitSuperGetterFieldCompound(ast.Send node, FunctionElement getter,
-      FieldElement field, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, field, rhs);
-  }
-
-  @override
-  T visitSuperGetterSetterCompound(ast.Send node, FunctionElement getter,
-      FunctionElement setter, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, setter, rhs);
-  }
-
-  @override
-  T visitSuperMethodSetterCompound(ast.Send node, FunctionElement method,
-      FunctionElement setter, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, method, setter, rhs);
-  }
-
-  @override
-  T visitUnresolvedSuperCompound(ast.Send node, Element element,
-      op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, element, element, rhs);
-  }
-
-  @override
-  T visitUnresolvedSuperGetterCompound(ast.Send node, Element getter,
-      SetterElement setter, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, setter, rhs);
-  }
-
-  @override
-  T visitUnresolvedSuperSetterCompound(ast.Send node, GetterElement getter,
-      Element setter, op.AssignmentOperator operator, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, setter, rhs);
-  }
-
-  @override
-  T visitSuperFieldFieldSetIfNull(ast.Send node, FieldElement readField,
-      FieldElement writtenField, ast.Node rhs, _) {
-    return handleSuperCompound(node, readField, writtenField, rhs);
-  }
-
-  @override
-  T visitSuperFieldSetIfNull(
-      ast.Send node, FieldElement field, ast.Node rhs, _) {
-    return handleSuperCompound(node, field, field, rhs);
-  }
-
-  @override
-  T visitSuperFieldSetterSetIfNull(ast.Send node, FieldElement field,
-      FunctionElement setter, ast.Node rhs, _) {
-    return handleSuperCompound(node, field, setter, rhs);
-  }
-
-  @override
-  T visitSuperGetterFieldSetIfNull(ast.Send node, FunctionElement getter,
-      FieldElement field, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, field, rhs);
-  }
-
-  @override
-  T visitSuperGetterSetterSetIfNull(ast.Send node, FunctionElement getter,
-      FunctionElement setter, ast.Node rhs, _) {
-    return handleSuperCompound(node, getter, setter, rhs);
-  }
-
-  @override
-  T visitSuperMethodSetIfNull(
-      ast.Send node, FunctionElement method, ast.Node rhs, _) {
-    return handleSuperCompound(node, method, null, rhs);
-  }
-
-  @override
-  T visitSuperMethodSetterSetIfNull(ast.Send node, FunctionElement method,
-      FunctionElement setter, ast.Node rhs, _) {
-    return handleSuperCompound(node, method, setter, rhs);
-  }
-
-  T handleSuperCompound(
-      ast.SendSet node, Element getter, Element setter, ast.Node rhs) {
-    T rhsType = visit(rhs);
-    return _handleSuperCompound(node, getter, setter, rhsType);
-  }
-
-  @override
-  T visitSuperFieldFieldPostfix(ast.SendSet node, FieldElement readField,
-      FieldElement writtenField, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, readField, writtenField);
-  }
-
-  @override
-  T visitSuperFieldFieldPrefix(ast.SendSet node, FieldElement readField,
-      FieldElement writtenField, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, readField, writtenField);
-  }
-
-  @override
-  T visitSuperFieldPostfix(
-      ast.SendSet node, FieldElement field, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, field, field);
-  }
-
-  @override
-  T visitSuperFieldPrefix(
-      ast.SendSet node, FieldElement field, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, field, field);
-  }
-
-  @override
-  T visitSuperFieldSetterPostfix(ast.SendSet node, FieldElement field,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, field, setter);
-  }
-
-  @override
-  T visitSuperFieldSetterPrefix(ast.SendSet node, FieldElement field,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, field, setter);
-  }
-
-  @override
-  T visitSuperGetterFieldPostfix(ast.SendSet node, FunctionElement getter,
-      FieldElement field, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, field);
-  }
-
-  @override
-  T visitSuperGetterFieldPrefix(ast.SendSet node, FunctionElement getter,
-      FieldElement field, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, field);
-  }
-
-  @override
-  T visitSuperGetterSetterPostfix(ast.SendSet node, FunctionElement getter,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  @override
-  T visitSuperGetterSetterPrefix(ast.SendSet node, FunctionElement getter,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  @override
-  T visitSuperMethodSetterPostfix(ast.SendSet node, FunctionElement method,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, method, setter);
-  }
-
-  @override
-  T visitSuperMethodSetterPrefix(ast.SendSet node, FunctionElement method,
-      FunctionElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, method, setter);
-  }
-
-  @override
-  T visitUnresolvedSuperPrefix(
-      ast.SendSet node, Element element, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, element, element);
-  }
-
-  @override
-  T visitUnresolvedSuperPostfix(
-      ast.SendSet node, Element element, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, element, element);
-  }
-
-  @override
-  T visitUnresolvedSuperGetterPrefix(ast.SendSet node, Element getter,
-      SetterElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  @override
-  T visitUnresolvedSuperGetterPostfix(ast.SendSet node, Element getter,
-      SetterElement setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  @override
-  T visitUnresolvedSuperSetterPrefix(ast.SendSet node, GetterElement getter,
-      Element setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  @override
-  T visitUnresolvedSuperSetterPostfix(ast.SendSet node, GetterElement getter,
-      Element setter, op.IncDecOperator operator, _) {
-    return handleSuperPrefixPostfix(node, getter, setter);
-  }
-
-  T handleSuperPrefixPostfix(ast.SendSet node, Element getter, Element setter) {
-    return _handleSuperCompound(node, getter, setter, types.uint31Type);
-  }
-
-  T _handleSuperCompound(
-      ast.SendSet node, Element getter, Element setter, T rhsType) {
-    Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
-    TypeMask getterMask = elements.getGetterTypeMaskInComplexSendSet(node);
-    Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
-
-    T getterType =
-        handleSuperSend(node, getterSelector, getterMask, getter, null);
-
-    T returnType;
-    if (node.isIfNullAssignment) {
-      returnType = types.allocateDiamondPhi(getterType, rhsType);
-    } else {
-      Selector operatorSelector =
-          elements.getOperatorSelectorInComplexSendSet(node);
-      TypeMask operatorMask =
-          elements.getOperatorTypeMaskInComplexSendSet(node);
-      returnType = handleDynamicSend(node, operatorSelector, operatorMask,
-          getterType, new ArgumentsTypes<T>([rhsType], null));
-    }
-    handleSuperSend(node, setterSelector, setterMask, setter,
-        new ArgumentsTypes<T>([returnType], null));
-
-    return node.isPostfix ? getterType : returnType;
+    return handleCompoundPrefixPostfix(node, superType, indexType);
   }
 
   /// Handle index set, like `foo[0] = 42`.
@@ -1312,27 +1034,23 @@ class SimpleTypeInferrerVisitor<T>
   }
 
   /// Handle super index set, like `super[42] = true`.
-  T handleSuperIndexSet(
-      ast.SendSet node, Element element, ast.Node index, ast.Node rhs) {
+  T handleSuperIndexSet(ast.SendSet node, ast.Node index, ast.Node rhs) {
+    T receiverType = superType;
     T indexType = visit(index);
     T rhsType = visit(rhs);
-    Selector setterSelector = elements.getSelector(node);
-    TypeMask setterMask = elements.getTypeMask(node);
-    handleStaticSend(node, setterSelector, setterMask, element,
-        new ArgumentsTypes<T>([indexType, rhsType], null));
-    return rhsType;
+    return handleIndexSet(node, receiverType, indexType, rhsType);
   }
 
   @override
   T visitSuperIndexSet(ast.SendSet node, FunctionElement function,
       ast.Node index, ast.Node rhs, _) {
-    return handleSuperIndexSet(node, function, index, rhs);
+    return handleSuperIndexSet(node, index, rhs);
   }
 
   @override
   T visitUnresolvedSuperIndexSet(
       ast.SendSet node, Element element, ast.Node index, ast.Node rhs, _) {
-    return handleSuperIndexSet(node, element, index, rhs);
+    return handleSuperIndexSet(node, index, rhs);
   }
 
   T handlePlainAssignment(
@@ -1396,22 +1114,10 @@ class SimpleTypeInferrerVisitor<T>
     TypeMask mask = elements.getTypeMask(node);
     // TODO(herhut): We could do better here if we knew what we
     // are calling does not expose this.
-    // TODO(johnniwinther): Do we still need this when calling directly?
     isThisExposed = true;
-    return handleSuperNoSuchMethod(node, selector, mask, arguments);
-  }
-
-  T handleSuperNoSuchMethod(ast.Send node, Selector selector, TypeMask mask,
-      ArgumentsTypes arguments) {
     // Ensure we create a node, to make explicit the call to the
     // `noSuchMethod` handler.
-    ClassElement cls = outermostElement.enclosingClass.declaration;
-    MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
-    if (!Selectors.noSuchMethod_.signatureApplies(element)) {
-      element = compiler.coreClasses.objectClass
-          .lookupMember(Identifiers.noSuchMethod_);
-    }
-    return handleStaticSend(node, selector, mask, element, arguments);
+    return handleDynamicSend(node, selector, mask, superType, arguments);
   }
 
   /// Handle a .call invocation on the values retrieved from the super
@@ -1456,28 +1162,6 @@ class SimpleTypeInferrerVisitor<T>
     return handleStaticSend(node, selector, mask, element, null);
   }
 
-  /// Handle update to a super field or setter [element].
-  T handleSuperSet(ast.Send node, Element element, ast.Node rhs) {
-    T rhsType = visit(rhs);
-    // TODO(herhut): We could do better here if we knew what we
-    // are calling does not expose this.
-    isThisExposed = true;
-    Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
-    return handleStaticSend(
-        node, selector, mask, element, new ArgumentsTypes<T>([rhsType], null));
-  }
-
-  @override
-  T visitSuperFieldSet(ast.Send node, FieldElement method, ast.Node rhs, _) {
-    return handleSuperSet(node, method, rhs);
-  }
-
-  @override
-  T visitSuperSetterSet(ast.Send node, SetterElement field, ast.Node rhs, _) {
-    return handleSuperSet(node, field, rhs);
-  }
-
   @override
   T visitUnresolvedSuperIndex(
       ast.Send node, Element element, ast.Node index, _) {
@@ -1512,17 +1196,6 @@ class SimpleTypeInferrerVisitor<T>
   }
 
   @override
-  T visitSuperMethodSet(ast.Send node, MethodElement method, ast.Node rhs, _) {
-    return handleErroneousSuperSend(node);
-  }
-
-  @override
-  T visitFinalSuperFieldSet(
-      ast.Send node, FieldElement method, ast.Node rhs, _) {
-    return handleErroneousSuperSend(node);
-  }
-
-  @override
   T visitUnresolvedSuperSet(ast.Send node, Element element, ast.Node rhs, _) {
     return handleErroneousSuperSend(node);
   }