All strong mode cleaning of dart2js.

pkg/compiler/lib/src/kernel/unresolved.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 
 import "../elements/elements.dart"
     show
         AstElement,
         ConstructorElement,
         Element,
         ErroneousElement,
         FunctionElement,
-        MethodElement;
+        GetterElement,
+        MethodElement,
+        SetterElement;
 import "../elements/operators.dart"
     show AssignmentOperator, BinaryOperator, IncDecOperator, UnaryOperator;
 import "../elements/resolution_types.dart"
     show ResolutionDartType, ResolutionInterfaceType;
-import "../tree/tree.dart" show Expression, NewExpression, Node, NodeList, Send;
+import "../tree/tree.dart"
+    show Expression, NewExpression, Node, NodeList, Send, SendSet;
 import "../universe/call_structure.dart" show CallStructure;
 import "../universe/selector.dart" show Selector;
 import 'accessors.dart';
 import "kernel.dart" show Kernel;
 
 abstract class UnresolvedVisitor {
   Kernel get kernel;
 
   // Implemented in KernelVisitor
   AstElement get currentElement;
@@ skipping 147 matching lines @@
       NodeList arguments,
       Selector selector,
       _) {
     ir.Expression receiver = new ir.TypeLiteral(kernel.interfaceTypeToIr(type));
     String methodName =
         node.send.selector != null ? '${node.send.selector}' : type.name;
     return buildThrowNoSuchMethodError(kernel.getUnresolvedConstructorBuilder(),
         receiver, methodName, buildArguments(arguments), constructor);
   }
 
-  ir.Expression visitUnresolvedCompound(
-      Send node, Element element, AssignmentOperator operator, Node rhs, _) {
+  ir.Expression visitUnresolvedCompound(Send node, ErroneousElement element,
+      AssignmentOperator operator, Node rhs, _) {
     return buildThrowUnresolvedGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedGet(Send node, Element element, _) {
     return buildThrowUnresolvedGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedInvoke(
       Send node, Element element, NodeList arguments, Selector selector, _) {
     // TODO(asgerf): Should we use a type literal as receiver for unresolved
     //   static invocations?
     return buildThrowNoSuchMethodError(kernel.getGenericNoSuchMethodBuilder(),
         new ir.NullLiteral(), element.name, buildArguments(arguments), element);
   }
 
   ir.Expression visitUnresolvedPostfix(
-      Send node, Element element, IncDecOperator operator, _) {
+      Send node, ErroneousElement element, IncDecOperator operator, _) {
     return buildThrowUnresolvedGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedPrefix(
-      Send node, Element element, IncDecOperator operator, _) {
+      Send node, ErroneousElement element, IncDecOperator operator, _) {
     return buildThrowUnresolvedGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
       ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     // The body of the factory will throw an error.
     return new ir.StaticInvocation(
         possiblyErroneousFunctionToIr(constructor), buildArguments(arguments));
   }
 
-  ir.Expression visitUnresolvedSet(Send node, Element element, Node rhs, _) {
+  ir.Expression visitUnresolvedSet(SendSet node, Element element, Node rhs, _) {
     return buildThrowUnresolvedSetter('${node.selector}', visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSetIfNull(
       Send node, Element element, Node rhs, _) {
     return buildThrowUnresolvedGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedStaticGetterCompound(Send node, Element element,
       MethodElement setter, AssignmentOperator operator, Node rhs, _) {
@@ skipping 14 matching lines @@
   }
 
   ir.Expression visitUnresolvedStaticGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, _) {
     return buildThrowUnresolvedGetter(
         '${node.selector}', kernel.getUnresolvedStaticGetterBuilder());
   }
 
   ir.Expression visitUnresolvedStaticSetterCompound(
       Send node,
-      MethodElement getter,
+      GetterElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return buildThrowUnresolvedSetter('${node.selector}', visitForValue(rhs),
         kernel.getUnresolvedStaticSetterBuilder());
   }
 
   ir.Expression visitUnresolvedStaticSetterPostfix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     var accessor = new ClassStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     var result = accessor.buildPostfixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
     associateCompoundComponents(accessor, node);
     return result;
   }
 
   ir.Expression visitUnresolvedStaticSetterPrefix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     var accessor = new ClassStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     var result = accessor.buildPrefixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
     associateCompoundComponents(accessor, node);
     return result;
   }
 
   ir.Expression visitUnresolvedStaticSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, _) {
+      Send node, GetterElement getter, Element element, Node rhs, _) {
     var accessor = new ClassStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   ir.Expression visitUnresolvedSuperBinary(
       Send node, Element element, BinaryOperator operator, Node argument, _) {
     // TODO(sra): This is incorrect when the superclass defines noSuchMethod.
     return buildThrowNoSuchMethodError(
         kernel.getUnresolvedSuperMethodBuilder(),
         new ir.ThisExpression(),
         operator.selectorName,
         new ir.Arguments(<ir.Expression>[visitForValue(argument)]));
   }
 
   ir.Expression visitUnresolvedSuperCompound(
       Send node, Element element, AssignmentOperator operator, Node rhs, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.Expression visitUnresolvedSuperCompoundIndexSet(Send node, Element element,
-      Node index, AssignmentOperator operator, Node rhs, _) {
+  ir.Expression visitUnresolvedSuperCompoundIndexSet(SendSet node,
+      Element element, Node index, AssignmentOperator operator, Node rhs, _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildCompoundAssignment(
             new ir.Name(operator.selectorName), visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperGet(Send node, Element element, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.Expression visitUnresolvedSuperGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, _) {
+  ir.Expression visitUnresolvedSuperGetterCompound(
+      SendSet node,
+      Element element,
+      SetterElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperGetterCompoundIndexSet(
-      Send node,
+      SendSet node,
       Element element,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperGetterIndexPostfix(
-      Send node,
+      SendSet node,
       Element element,
       MethodElement setter,
       Node index,
       IncDecOperator operator,
       _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperGetterIndexPrefix(
-      Send node,
+      SendSet node,
       Element element,
       MethodElement setter,
       Node index,
       IncDecOperator operator,
       _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.Expression visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, _) {
+  ir.Expression visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
-  ir.Expression visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, _) {
+  ir.Expression visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperIndex(
       Send node, Element element, Node index, _) {
     return buildUnresolvedSuperIndexAccessor(index, element).buildSimpleRead();
   }
 
   ir.Expression visitUnresolvedSuperIndexPostfix(
       Send node, Element element, Node index, IncDecOperator operator, _) {
     return buildUnresolvedSuperIndexAccessor(index, element).buildSimpleRead();
   }
 
   ir.Expression visitUnresolvedSuperIndexPrefix(
       Send node, Element element, Node index, IncDecOperator operator, _) {
     return buildUnresolvedSuperIndexAccessor(index, element).buildSimpleRead();
   }
 
   ir.Expression visitUnresolvedSuperIndexSet(
-      Send node, Element element, Node index, Node rhs, _) {
+      SendSet node, ErroneousElement element, Node index, Node rhs, _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildAssignment(visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperInvoke(
       Send node, Element element, NodeList arguments, Selector selector, _) {
     // TODO(asgerf): Should really invoke 'super.noSuchMethod'.
     return buildThrowNoSuchMethodError(kernel.getUnresolvedSuperMethodBuilder(),
         new ir.ThisExpression(), '${node.selector}', buildArguments(arguments));
   }
 
   ir.Expression visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, _) {
+      SendSet node, Element element, IncDecOperator operator, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperPrefix(
-      Send node, Element element, IncDecOperator operator, _) {
+      SendSet node, Element element, IncDecOperator operator, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperSetIfNull(
       Send node, Element element, Node rhs, _) {
     return buildThrowUnresolvedSuperGetter('${node.selector}');
   }
 
   ir.Expression visitUnresolvedSuperSetterCompound(
       Send node,
-      MethodElement getter,
+      GetterElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return buildUnresolvedSuperPropertyAccessor('${node.selector}', getter)
         .buildCompoundAssignment(
             new ir.Name(operator.selectorName), visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSetterCompoundIndexSet(
-      Send node,
+      SendSet node,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildCompoundAssignment(
             new ir.Name(operator.selectorName), visitForValue(rhs));
   }
 
   ir.Expression visitUnresolvedSuperSetterIndexPostfix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildPostfixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterIndexPrefix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildPrefixIncrement(new ir.Name(operator.selectorName));
   }
 
-  ir.Expression visitUnresolvedSuperSetterPostfix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+  ir.Expression visitUnresolvedSuperSetterPostfix(SendSet node,
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     return buildUnresolvedSuperPropertyAccessor('${node.selector}', getter)
         .buildPostfixIncrement(new ir.Name(operator.selectorName));
   }
 
-  ir.Expression visitUnresolvedSuperSetterPrefix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+  ir.Expression visitUnresolvedSuperSetterPrefix(SendSet node,
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     return buildUnresolvedSuperPropertyAccessor('${node.selector}', getter)
         .buildPrefixIncrement(new ir.Name(operator.selectorName));
   }
 
   ir.Expression visitUnresolvedSuperSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, _) {
+      Send node, GetterElement getter, Element element, Node rhs, _) {
     return buildUnresolvedSuperPropertyAccessor('${node.selector}', getter)
         .buildNullAwareAssignment(visitForValue(rhs), null);
   }
 
   ir.Expression visitUnresolvedSuperUnary(
       Send node, UnaryOperator operator, Element element, _) {
     // TODO(asgerf): Should really call 'super.noSuchMethod'.
     return buildThrowNoSuchMethodError(
         kernel.getUnresolvedSuperMethodBuilder(),
         new ir.ThisExpression(),
@@ skipping 25 matching lines @@
   }
 
   ir.Expression visitUnresolvedTopLevelGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, _) {
     return buildThrowUnresolvedGetter(
         '${node.selector}', kernel.getUnresolvedTopLevelGetterBuilder());
   }
 
   ir.Expression visitUnresolvedTopLevelSetterCompound(
       Send node,
-      MethodElement getter,
+      GetterElement getter,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       _) {
     var accessor = new TopLevelStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     var result = accessor.buildCompoundAssignment(
         new ir.Name(operator.selectorName), visitForValue(rhs),
         voidContext: isVoidContext);
     associateCompoundComponents(accessor, node);
     return result;
   }
 
   ir.Expression visitUnresolvedTopLevelSetterPostfix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     var accessor = new TopLevelStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     var result = accessor.buildPostfixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
     associateCompoundComponents(accessor, node);
     return result;
   }
 
   ir.Expression visitUnresolvedTopLevelSetterPrefix(Send node,
-      MethodElement getter, Element element, IncDecOperator operator, _) {
+      GetterElement getter, Element element, IncDecOperator operator, _) {
     var accessor = new TopLevelStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     var result = accessor.buildPrefixIncrement(
         new ir.Name(operator.selectorName),
         voidContext: isVoidContext);
     associateCompoundComponents(accessor, node);
     return result;
   }
 
   ir.Expression visitUnresolvedTopLevelSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, _) {
+      Send node, GetterElement getter, Element element, Node rhs, _) {
     var accessor = new TopLevelStaticAccessor(
         this, getter.name, possiblyErroneousFunctionToIr(getter), null);
     return accessor.buildNullAwareAssignment(visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
-  ir.Expression visitUnresolvedSuperGetterIndexSetIfNull(Send node,
+  ir.Expression visitUnresolvedSuperGetterIndexSetIfNull(SendSet node,
       Element element, MethodElement setter, Node index, Node rhs, _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildNullAwareAssignment(visitForValue(rhs), null);
   }
 
-  ir.Expression visitUnresolvedSuperSetterIndexSetIfNull(Send node,
+  ir.Expression visitUnresolvedSuperSetterIndexSetIfNull(SendSet node,
       MethodElement getter, Element element, Node index, Node rhs, _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildNullAwareAssignment(visitForValue(rhs), null);
   }
 
   ir.Expression visitUnresolvedSuperIndexSetIfNull(
       Send node, Element element, Node index, Node rhs, _) {
     return buildUnresolvedSuperIndexAccessor(index, element)
         .buildNullAwareAssignment(visitForValue(rhs), null);
   }
 
   ir.Expression visitUnresolvedSuperSet(
       Send node, Element element, Node rhs, _) {
     return buildThrowUnresolvedSuperSetter(
         '${node.selector}', visitForValue(rhs));
   }
 }