All strong mode cleaning of dart2js.

pkg/compiler/lib/src/inferrer/builder.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.
 
 library simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 125 matching lines @@
     if (analyzedElement.isGenerativeConstructor) {
       locals.fieldScope.isIndefinite = true;
     }
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   ClosedWorld get closedWorld => inferrer.closedWorld;
 
   @override
-  SemanticSendVisitor get sendVisitor => this;
+  SemanticSendVisitor<TypeInformation, dynamic> get sendVisitor => this;
 
   @override
   TypeInformation apply(ast.Node node, _) => visit(node);
 
   TypeInformation visitAssert(ast.Assert node) {
     // Avoid pollution from assert statement unless enabled.
     if (!compiler.options.enableUserAssertions) {
       return null;
     }
     List<ast.Send> tests = <ast.Send>[];
@@ skipping 1351 matching lines @@
       MethodElement getter,
       MethodElement setter,
       ast.Node index,
       ast.Node rhs,
       _) {
     return handleSuperCompoundIndexSet(node, getter, setter, index, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperCompoundIndexSet(
-      ast.Send node,
+      ast.SendSet node,
       Element element,
       ast.Node index,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompoundIndexSet(node, element, element, index, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperIndexSetIfNull(
@@ skipping 102 matching lines @@
   @override
   TypeInformation visitSuperFieldCompound(ast.Send node, FieldElement field,
       op.AssignmentOperator operator, ast.Node rhs, _) {
     return handleSuperCompound(node, field, field, rhs);
   }
 
   @override
   TypeInformation visitSuperFieldSetterCompound(
       ast.Send node,
       FieldElement field,
-      FunctionElement setter,
+      SetterElement setter,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompound(node, field, setter, rhs);
   }
 
   @override
   TypeInformation visitSuperGetterFieldCompound(
       ast.Send node,
-      FunctionElement getter,
+      GetterElement getter,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompound(node, getter, field, rhs);
   }
 
   @override
   TypeInformation visitSuperGetterSetterCompound(
       ast.Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      GetterElement getter,
+      SetterElement setter,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompound(node, getter, setter, rhs);
   }
 
   @override
   TypeInformation visitSuperMethodSetterCompound(
       ast.Send node,
       FunctionElement method,
-      FunctionElement setter,
+      SetterElement setter,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompound(node, method, setter, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperCompound(ast.Send node, Element element,
       op.AssignmentOperator operator, ast.Node rhs, _) {
     return handleSuperCompound(node, element, element, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperGetterCompound(
-      ast.Send node,
+      ast.SendSet node,
       Element getter,
       SetterElement setter,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return handleSuperCompound(node, getter, setter, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperSetterCompound(
@@ skipping 13 matching lines @@
   }
 
   @override
   TypeInformation visitSuperFieldSetIfNull(
       ast.Send node, FieldElement field, ast.Node rhs, _) {
     return handleSuperCompound(node, field, field, rhs);
   }
 
   @override
   TypeInformation visitSuperFieldSetterSetIfNull(ast.Send node,
-      FieldElement field, FunctionElement setter, ast.Node rhs, _) {
+      FieldElement field, SetterElement setter, ast.Node rhs, _) {
     return handleSuperCompound(node, field, setter, rhs);
   }
 
   @override
   TypeInformation visitSuperGetterFieldSetIfNull(ast.Send node,
-      FunctionElement getter, FieldElement field, ast.Node rhs, _) {
+      GetterElement getter, FieldElement field, ast.Node rhs, _) {
     return handleSuperCompound(node, getter, field, rhs);
   }
 
   @override
   TypeInformation visitSuperGetterSetterSetIfNull(ast.Send node,
-      FunctionElement getter, FunctionElement setter, ast.Node rhs, _) {
+      GetterElement getter, SetterElement setter, ast.Node rhs, _) {
     return handleSuperCompound(node, getter, setter, rhs);
   }
 
   @override
   TypeInformation visitSuperMethodSetIfNull(
       ast.Send node, FunctionElement method, ast.Node rhs, _) {
     return handleSuperCompound(node, method, null, rhs);
   }
 
   @override
   TypeInformation visitSuperMethodSetterSetIfNull(ast.Send node,
-      FunctionElement method, FunctionElement setter, ast.Node rhs, _) {
+      FunctionElement method, SetterElement setter, ast.Node rhs, _) {
     return handleSuperCompound(node, method, setter, rhs);
   }
 
   TypeInformation handleSuperCompound(
       ast.SendSet node, Element getter, Element setter, ast.Node rhs) {
     TypeInformation rhsType = visit(rhs);
     return _handleSuperCompound(node, getter, setter, rhsType);
   }
 
   @override
@@ skipping 22 matching lines @@
     return handleSuperPrefixPostfix(node, field, field);
   }
 
   @override
   TypeInformation visitSuperFieldPrefix(
       ast.SendSet node, FieldElement field, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, field, field);
   }
 
   @override
-  TypeInformation visitSuperFieldSetterPostfix(
-      ast.SendSet node,
-      FieldElement field,
-      FunctionElement setter,
-      op.IncDecOperator operator,
-      _) {
+  TypeInformation visitSuperFieldSetterPostfix(ast.SendSet node,
+      FieldElement field, SetterElement setter, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, field, setter);
   }
 
   @override
-  TypeInformation visitSuperFieldSetterPrefix(
-      ast.SendSet node,
-      FieldElement field,
-      FunctionElement setter,
-      op.IncDecOperator operator,
-      _) {
+  TypeInformation visitSuperFieldSetterPrefix(ast.SendSet node,
+      FieldElement field, SetterElement setter, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, field, setter);
   }
 
   @override
-  TypeInformation visitSuperGetterFieldPostfix(
-      ast.SendSet node,
-      FunctionElement getter,
-      FieldElement field,
-      op.IncDecOperator operator,
-      _) {
+  TypeInformation visitSuperGetterFieldPostfix(ast.SendSet node,
+      GetterElement getter, FieldElement field, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, getter, field);
   }
 
   @override
-  TypeInformation visitSuperGetterFieldPrefix(
-      ast.SendSet node,
-      FunctionElement getter,
-      FieldElement field,
-      op.IncDecOperator operator,
-      _) {
+  TypeInformation visitSuperGetterFieldPrefix(ast.SendSet node,
+      GetterElement getter, FieldElement field, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, getter, field);
   }
 
   @override
   TypeInformation visitSuperGetterSetterPostfix(
       ast.SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
+      GetterElement getter,
+      SetterElement setter,
       op.IncDecOperator operator,
       _) {
     return handleSuperPrefixPostfix(node, getter, setter);
   }
 
   @override
   TypeInformation visitSuperGetterSetterPrefix(
       ast.SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
+      GetterElement getter,
+      SetterElement setter,
       op.IncDecOperator operator,
       _) {
     return handleSuperPrefixPostfix(node, getter, setter);
   }
 
   @override
   TypeInformation visitSuperMethodSetterPostfix(
       ast.SendSet node,
       FunctionElement method,
-      FunctionElement setter,
+      SetterElement setter,
       op.IncDecOperator operator,
       _) {
     return handleSuperPrefixPostfix(node, method, setter);
   }
 
   @override
   TypeInformation visitSuperMethodSetterPrefix(
       ast.SendSet node,
       FunctionElement method,
-      FunctionElement setter,
+      SetterElement setter,
       op.IncDecOperator operator,
       _) {
     return handleSuperPrefixPostfix(node, method, setter);
   }
 
   @override
   TypeInformation visitUnresolvedSuperPrefix(
       ast.SendSet node, Element element, op.IncDecOperator operator, _) {
     return handleSuperPrefixPostfix(node, element, element);
   }
@@ skipping 90 matching lines @@
     return rhsType;
   }
 
   @override
   TypeInformation visitSuperIndexSet(ast.SendSet node, FunctionElement function,
       ast.Node index, ast.Node rhs, _) {
     return handleSuperIndexSet(node, function, index, rhs);
   }
 
   @override
-  TypeInformation visitUnresolvedSuperIndexSet(
-      ast.SendSet node, Element element, ast.Node index, ast.Node rhs, _) {
+  TypeInformation visitUnresolvedSuperIndexSet(ast.SendSet node,
+      ErroneousElement element, ast.Node index, ast.Node rhs, _) {
     return handleSuperIndexSet(node, element, index, rhs);
   }
 
   TypeInformation handlePlainAssignment(
       ast.Node node,
       Element element,
       Selector setterSelector,
       TypeMask setterMask,
       TypeInformation receiverType,
       TypeInformation rhsType,
@@ skipping 125 matching lines @@
   }
 
   @override
   TypeInformation visitSuperFieldSet(
       ast.Send node, FieldElement method, ast.Node rhs, _) {
     return handleSuperSet(node, method, rhs);
   }
 
   @override
   TypeInformation visitSuperSetterSet(
-      ast.Send node, SetterElement field, ast.Node rhs, _) {
+      ast.SendSet node, SetterElement field, ast.Node rhs, _) {
     return handleSuperSet(node, field, rhs);
   }
 
   @override
   TypeInformation visitUnresolvedSuperIndex(
       ast.Send node, Element element, ast.Node index, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
@@ skipping 13 matching lines @@
     return handleErroneousSuperSend(node);
   }
 
   @override
   TypeInformation visitSuperSetterGet(ast.Send node, MethodElement setter, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
   TypeInformation visitSuperGetterSet(
-      ast.Send node, MethodElement getter, ast.Node rhs, _) {
+      ast.Send node, GetterElement getter, ast.Node rhs, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
   TypeInformation visitSuperMethodSet(
-      ast.Send node, MethodElement method, ast.Node rhs, _) {
+      ast.SendSet node, MethodElement method, ast.Node rhs, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
   TypeInformation visitFinalSuperFieldSet(
       ast.Send node, FieldElement method, ast.Node rhs, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
@@ skipping 23 matching lines @@
     return handleSuperGet(node, method);
   }
 
   @override
   TypeInformation visitSuperFieldInvoke(ast.Send node, FieldElement field,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleSuperClosureCall(node, field, arguments);
   }
 
   @override
-  TypeInformation visitSuperGetterInvoke(ast.Send node, MethodElement getter,
+  TypeInformation visitSuperGetterInvoke(ast.Send node, GetterElement getter,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleSuperClosureCall(node, getter, arguments);
   }
 
   @override
   TypeInformation visitSuperMethodInvoke(ast.Send node, MethodElement method,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleSuperMethodInvoke(
         node, method, analyzeArguments(arguments.nodes));
   }
 
   @override
-  TypeInformation visitSuperSetterInvoke(ast.Send node, FunctionElement setter,
+  TypeInformation visitSuperSetterInvoke(ast.Send node, SetterElement setter,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleErroneousSuperSend(node);
   }
 
   @override
   TypeInformation visitSuperIndex(
       ast.Send node, MethodElement method, ast.Node index, _) {
     return handleSuperMethodInvoke(
         node, method, analyzeArguments(node.arguments));
   }
@@ skipping 224 matching lines @@
   TypeInformation visitStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return handleInvalidStaticInvoke(node);
   }
 
   @override
-  TypeInformation visitStaticGetterInvoke(ast.Send node, FunctionElement getter,
+  TypeInformation visitStaticGetterInvoke(ast.Send node, GetterElement getter,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleStaticFieldOrGetterInvoke(node, getter);
   }
 
   @override
   TypeInformation visitTopLevelFieldInvoke(ast.Send node, FieldElement field,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleStaticFieldOrGetterInvoke(node, field);
   }
 
@@ skipping 11 matching lines @@
   TypeInformation visitTopLevelFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return handleInvalidStaticInvoke(node);
   }
 
   @override
-  TypeInformation visitTopLevelGetterInvoke(
-      ast.Send node,
-      FunctionElement getter,
-      ast.NodeList arguments,
-      CallStructure callStructure,
-      _) {
+  TypeInformation visitTopLevelGetterInvoke(ast.Send node, GetterElement getter,
+      ast.NodeList arguments, CallStructure callStructure, _) {
     return handleStaticFieldOrGetterInvoke(node, getter);
   }
 
   @override
   TypeInformation visitStaticSetterInvoke(ast.Send node, MethodElement setter,
       ast.NodeList arguments, CallStructure callStructure, _) {
     return handleInvalidStaticInvoke(node);
   }
 
   @override
@@ skipping 54 matching lines @@
   }
 
   /// Read a static or top level field.
   TypeInformation handleStaticFieldGet(ast.Send node, FieldElement field) {
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, field, null);
   }
 
   /// Invoke a static or top level getter.
-  TypeInformation handleStaticGetterGet(ast.Send node, MethodElement getter) {
+  TypeInformation handleStaticGetterGet(ast.Send node, GetterElement getter) {
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, getter, null);
   }
 
   /// Closurize a static or top level function.
   TypeInformation handleStaticFunctionGet(
       ast.Send node, MethodElement function) {
     Selector selector = elements.getSelector(node);
     TypeMask mask = inTreeData.typeOfSend(node);
@@ skipping 35 matching lines @@
     return handleStaticFieldGet(node, field);
   }
 
   @override
   TypeInformation visitStaticFunctionGet(
       ast.Send node, MethodElement function, _) {
     return handleStaticFunctionGet(node, function);
   }
 
   @override
-  TypeInformation visitStaticGetterGet(
-      ast.Send node, FunctionElement getter, _) {
+  TypeInformation visitStaticGetterGet(ast.Send node, GetterElement getter, _) {
     return handleStaticGetterGet(node, getter);
   }
 
   @override
   TypeInformation visitThisPropertyGet(ast.Send node, Name name, _) {
     return handleDynamicGet(node);
   }
 
   @override
   TypeInformation visitTopLevelFieldGet(ast.Send node, FieldElement field, _) {
     return handleStaticFieldGet(node, field);
   }
 
   @override
   TypeInformation visitTopLevelFunctionGet(
       ast.Send node, MethodElement function, _) {
     return handleStaticFunctionGet(node, function);
   }
 
   @override
   TypeInformation visitTopLevelGetterGet(
-      ast.Send node, FunctionElement getter, _) {
+      ast.Send node, GetterElement getter, _) {
     return handleStaticGetterGet(node, getter);
   }
 
   @override
   TypeInformation visitStaticSetterGet(ast.Send node, MethodElement setter, _) {
     return types.dynamicType;
   }
 
   @override
   TypeInformation visitTopLevelSetterGet(
@@ skipping 292 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }