All strong mode cleaning of dart2js.

pkg/compiler/lib/src/kernel/kernel_visitor.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 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 199 matching lines @@
   // "import foo.dart deferred as bar"). LibraryElement corresponds to the
   // imported library element.
   final Map<LibraryElement, Map<String, ir.LibraryDependency>> deferredImports =
       <LibraryElement, Map<String, ir.LibraryDependency>>{};
 
   ir.Node associateElement(ir.Node node, Element element) {
     kernel.nodeToElement[node] = element;
     return node;
   }
 
-  ir.Node associateNode(ir.Node node, Node ast) {
+  N associateNode<N extends ir.Node>(N node, Node ast) {
     kernel.nodeToAst[node] = ast;
     return node;
   }
 
   bool isVoidContext = false;
 
   /// If non-null, reference to a deferred library that a subsequent getter is
   /// using.
   ir.LibraryDependency _deferredLibrary;
 
@@ skipping 1037 matching lines @@
   }
 
   ir.Expression buildTypeLiteralSet(TypeConstantExpression constant, Node rhs) {
     return new ReadOnlyAccessor(
             buildTypeLiteral(constant), ir.TreeNode.noOffset)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Expression visitClassTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, _) {
+      SendSet node, TypeConstantExpression constant, Node rhs, _) {
     return buildTypeLiteralSet(constant, rhs);
   }
 
   @override
   ir.FunctionExpression visitClosureDeclaration(FunctionExpression node,
       LocalFunctionElement closure, NodeList parameters, Node body, _) {
     return withCurrentElement(closure, () {
       ir.FunctionExpression function =
           new ir.FunctionExpression(buildFunctionNode(closure, body));
       kernel.localFunctions[closure] = function;
@@ skipping 116 matching lines @@
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildCall(buildTypeLiteral(constant), callStructure, arguments);
   }
 
   @override
   ir.Expression visitDynamicTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, _) {
+      SendSet node, TypeConstantExpression constant, Node rhs, _) {
     return buildTypeLiteralSet(constant, rhs);
   }
 
   ir.MethodInvocation buildBinaryOperator(
       Node left, String operator, Node right) {
     ir.Name name = kernel.irName(operator, currentElement);
     return makeBinary(visitForValue(left), name, null, visitForValue(right));
   }
 
   @override
@@ skipping 890 matching lines @@
       expression =
           new ir.LoadLibrary(getDeferredImport(getter.enclosingElement));
     } else {
       expression = buildStaticGet(getter);
     }
     return associateNode(buildCall(expression, callStructure, arguments), node);
   }
 
   @override
   ir.Expression handleStaticGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, _) {
+      SendSet node, GetterElement getter, Node rhs, _) {
     return buildStaticAccessor(getter)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitStaticSetterDeclaration(FunctionExpression node,
       MethodElement setter, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Setter, setter, body);
   }
 
@@ skipping 15 matching lines @@
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.InvocationExpression visitStringFromEnvironmentConstructorInvoke(
       NewExpression node, StringFromEnvironmentConstantExpression constant, _) {
     return associateNode(buildConstructorInvoke(node, isConst: true), node);
   }
 
   @override
-  ir.SuperMethodInvocation visitSuperBinary(Send node, FunctionElement function,
+  ir.SuperMethodInvocation visitSuperBinary(Send node, MethodElement function,
       BinaryOperator operator, Node argument, _) {
     transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(
         kernel.irName(operator.selectorName, currentElement),
         new ir.Arguments(<ir.Expression>[visitForValue(argument)]),
         kernel.functionToIr(function));
   }
 
   @override
   ir.Expression visitSuperCompoundIndexSet(
@@ skipping 32 matching lines @@
     transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(
         kernel.irName(function.name, function),
         new ir.Arguments(<ir.Expression>[visitForValue(argument)],
             types: null, named: null),
         kernel.functionToIr(function));
   }
 
   @override
   ir.SuperMethodInvocation visitSuperEquals(
-      Send node, FunctionElement function, Node argument, _) {
+      Send node, MethodElement function, Node argument, _) {
     return buildSuperEquals(function, argument);
   }
 
   @override
   ir.Expression handleSuperCompounds(
       SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
@@ skipping 86 matching lines @@
       setter = getter;
     }
     return new SuperIndexAccessor(
         visitForValue(index),
         (getter == null) ? null : kernel.elementToIr(getter),
         (setter == null) ? null : kernel.elementToIr(setter),
         ir.TreeNode.noOffset);
   }
 
   @override
-  ir.SuperPropertyGet visitSuperGetterGet(
-      Send node, FunctionElement getter, _) {
+  ir.SuperPropertyGet visitSuperGetterGet(Send node, MethodElement getter, _) {
     return buildSuperPropertyAccessor(getter).buildSimpleRead();
   }
 
   @override
   ir.MethodInvocation visitSuperGetterInvoke(Send node, FunctionElement getter,
       NodeList arguments, CallStructure callStructure, _) {
     return buildCall(buildSuperPropertyAccessor(getter).buildSimpleRead(),
         callStructure, arguments);
   }
 
@@ skipping 15 matching lines @@
       _) {
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return _finishSetIfNull(
         node, buildSuperPropertyAccessor(getter, setter), rhs);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperIndex(
-      Send node, FunctionElement function, Node index, _) {
+      Send node, MethodElement function, Node index, _) {
     return buildSuperIndexAccessor(index, function).buildSimpleRead();
   }
 
   @override
   ir.Expression visitSuperIndexPostfix(Send node, MethodElement indexFunction,
       MethodElement indexSetFunction, Node index, IncDecOperator operator, _) {
     Accessor accessor =
         buildSuperIndexAccessor(index, indexFunction, indexSetFunction);
     return buildIndexPostfix(node, accessor, operator);
   }
@@ skipping 40 matching lines @@
       Send node,
       MethodElement method,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return associateNode(buildSuperMethodInvoke(method, arguments), node);
   }
 
   @override
   ir.Expression visitSuperMethodSet(
-      Send node, MethodElement method, Node rhs, _) {
+      SendSet node, MethodElement method, Node rhs, _) {
     return buildSuperPropertyAccessor(method)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.Not visitSuperNotEquals(
-      Send node, FunctionElement function, Node argument, _) {
+      Send node, MethodElement function, Node argument, _) {
     return new ir.Not(buildSuperEquals(function, argument));
   }
 
   @override
   ir.Expression visitSuperSetterGet(Send node, FunctionElement setter, _) {
     return buildSuperPropertyAccessor(null, setter).buildSimpleRead();
   }
 
   @override
   ir.MethodInvocation visitSuperSetterInvoke(Send node, FunctionElement setter,
       NodeList arguments, CallStructure callStructure, _) {
     return buildCall(buildSuperPropertyAccessor(null, setter).buildSimpleRead(),
         callStructure, arguments);
   }
 
   @override
   ir.Expression visitSuperSetterSet(
       SendSet node, FunctionElement setter, Node rhs, _) {
     return buildSuperPropertyAccessor(null, setter)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   ir.SuperMethodInvocation visitSuperUnary(
-      Send node, UnaryOperator operator, FunctionElement function, _) {
+      Send node, UnaryOperator operator, MethodElement function, _) {
     transformerFlags |= TransformerFlag.superCalls;
     return new ir.SuperMethodInvocation(kernel.irName(function.name, function),
         new ir.Arguments.empty(), kernel.functionToIr(function));
   }
 
   @override
   ir.Initializer visitThisConstructorInvoke(
       Send node,
       ConstructorElement thisConstructor,
       NodeList arguments,
@@ skipping 157 matching lines @@
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return associateNode(
         buildCall(buildTypeLiteral(constant), callStructure, arguments), node);
   }
 
   @override
   ir.Expression visitTypedefTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, _) {
+      SendSet node, TypeConstantExpression constant, Node rhs, _) {
     return buildTypeLiteralSet(constant, rhs);
   }
 
   @override
   ir.Expression handleTypeLiteralConstantSetIfNulls(
       SendSet node, ConstantExpression constant, Node rhs, _) {
     // Degenerate case: ignores [rhs] as a type literal is never null.
     return buildTypeLiteral(constant);
   }
 
@@ skipping 129 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }