All strong mode cleaning of dart2js.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 105 matching lines @@
   final CodeEmitterTask emitter;
   final SourceInformationStrategy sourceInformationFactory;
 
   SsaAstBuilder(CompilerTask task, JavaScriptBackend backend,
       this.sourceInformationFactory)
       : emitter = backend.emitter,
         super(task, backend);
 
   DiagnosticReporter get reporter => backend.reporter;
 
-  HGraph build(ElementCodegenWorkItem work, ClosedWorld closedWorld) {
+  HGraph build(covariant ElementCodegenWorkItem work, ClosedWorld closedWorld) {
     return task.measure(() {
       if (handleConstantField(work, closedWorld)) {
         // No code is generated for `work.element`.
         return null;
       }
       MemberElement element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaAstGraphBuilder builder = new SsaAstGraphBuilder(
             work.element.implementation,
             work.resolvedAst,
@@ skipping 3178 matching lines @@
   void handleInvalidSuperInvoke(ast.Send node, ast.NodeList arguments) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(arguments.nodes, inputs);
     generateSuperNoSuchMethodSend(node, selector, inputs);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
-    return closedWorld.anyStrictSubclassOf(cls, (ClassElement subclass) {
+    return closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
       return !rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   HInstruction handleListConstructor(ResolutionInterfaceType type,
       ast.Node currentNode, HInstruction newObject) {
     if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
@@ skipping 105 matching lines @@
       ConstructorElement target = constructorDeclaration;
       while (target.isRedirectingFactory) {
         if (constructorDeclaration.redirectionDeferredPrefix != null) {
           generateIsDeferredLoadedCheckIfNeeded(
               target.redirectionDeferredPrefix, node);
         }
         target = target.immediateRedirectionTarget;
       }
     }
     ResolutionInterfaceType type = elements.getType(node);
-    ResolutionInterfaceType expectedType =
+    ResolutionDartType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor) ||
         compiler.elementHasCompileTimeError(constructor.enclosingClass)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
@@ skipping 137 matching lines @@
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(
       ast.NewExpression node, ResolutionInterfaceType type) {
     if (!options.enableTypeAssertions) return false;
 
     Map<ResolutionDartType, Set<ResolutionDartType>> seenChecksMap =
         new Map<ResolutionDartType, Set<ResolutionDartType>>();
     bool definitelyFails = false;
 
     void addTypeVariableBoundCheck(
-        ResolutionInterfaceType instance,
-        ResolutionDartType typeArgument,
-        ResolutionTypeVariableType typeVariable,
-        ResolutionDartType bound) {
+        InterfaceType _instance,
+        DartType _typeArgument,
+        TypeVariableType _typeVariable,
+        DartType _bound) {
       if (definitelyFails) return;
+      ResolutionInterfaceType instance = _instance;
+      ResolutionDartType typeArgument = _typeArgument;
+      ResolutionTypeVariableType typeVariable = _typeVariable;
+      ResolutionDartType bound = _bound;
 
       int subtypeRelation = types.computeSubtypeRelation(typeArgument, bound);
       if (subtypeRelation == DartTypes.IS_SUBTYPE) return;
 
       String message = "Can't create an instance of malbounded type '$type': "
           "'${typeArgument}' is not a subtype of bound '${bound}' for "
           "type variable '${typeVariable}' of type "
           "${type == instance
               ? "'${type.element.thisType}'"
               : "'${instance.element.thisType}' on the supertype "
@@ skipping 756 matching lines @@
   }
 
   @override
   void visitSuperIndexSet(ast.SendSet node, FunctionElement function,
       ast.Node index, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperMethodSet(
-      ast.Send node, MethodElement method, ast.Node rhs, _) {
+      ast.SendSet node, MethodElement method, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperSetterSet(
       ast.SendSet node, FunctionElement setter, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperIndexSet(
-      ast.Send node, Element element, ast.Node index, ast.Node rhs, _) {
+  void visitUnresolvedSuperIndexSet(ast.SendSet node, ErroneousElement element,
+      ast.Node index, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperIndexPrefix(
       ast.Send node,
       MethodElement indexFunction,
       MethodElement indexSetFunction,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperIndexPostfix(
       ast.Send node,
       MethodElement indexFunction,
       MethodElement indexSetFunction,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterIndexPrefix(ast.Send node, Element element,
+  void visitUnresolvedSuperGetterIndexPrefix(ast.SendSet node, Element element,
       MethodElement setter, ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterIndexPostfix(ast.Send node, Element element,
+  void visitUnresolvedSuperGetterIndexPostfix(ast.SendSet node, Element element,
       MethodElement setter, ast.Node index, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperSetterIndexPrefix(
-      ast.Send node,
+      ast.SendSet node,
       MethodElement indexFunction,
       Element element,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperSetterIndexPostfix(
-      ast.Send node,
+      ast.SendSet node,
       MethodElement indexFunction,
       Element element,
       ast.Node index,
       IncDecOperator operator,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperIndexPrefix(ast.Send node, Element element,
@@ skipping 14 matching lines @@
       MethodElement setter,
       ast.Node index,
       AssignmentOperator operator,
       ast.Node rhs,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperGetterCompoundIndexSet(
-      ast.Send node,
+      ast.SendSet node,
       Element element,
       MethodElement setter,
       ast.Node index,
       AssignmentOperator operator,
       ast.Node rhs,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperSetterCompoundIndexSet(
-      ast.Send node,
+      ast.SendSet node,
       MethodElement getter,
       Element element,
       ast.Node index,
       AssignmentOperator operator,
       ast.Node rhs,
       _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperCompoundIndexSet(ast.Send node, Element element,
+  void visitUnresolvedSuperCompoundIndexSet(ast.SendSet node, Element element,
       ast.Node index, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperFieldCompound(ast.Send node, FieldElement field,
       AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitFinalSuperFieldCompound(ast.Send node, FieldElement field,
       AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitFinalSuperFieldPrefix(
       ast.Send node, FieldElement field, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperPrefix(
-      ast.Send node, Element element, IncDecOperator operator, _) {
+      ast.SendSet node, Element element, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperPostfix(
-      ast.Send node, Element element, IncDecOperator operator, _) {
+      ast.SendSet node, Element element, IncDecOperator operator, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitUnresolvedSuperCompound(ast.Send node, Element element,
       AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
@@ skipping 14 matching lines @@
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperMethodSetterCompound(ast.Send node, FunctionElement method,
       FunctionElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitSuperMethodCompound(ast.Send node, FunctionElement method,
+  void visitSuperMethodCompound(ast.Send node, MethodElement method,
       AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperGetterCompound(ast.Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, ast.Node rhs, _) {
+  void visitUnresolvedSuperGetterCompound(ast.SendSet node, Element element,
+      SetterElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
-  void visitUnresolvedSuperSetterCompound(ast.Send node, MethodElement getter,
+  void visitUnresolvedSuperSetterCompound(ast.Send node, GetterElement getter,
       Element element, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
   @override
   void visitSuperFieldSetterCompound(ast.Send node, FieldElement field,
       FunctionElement setter, AssignmentOperator operator, ast.Node rhs, _) {
     handleSuperSendSet(node);
   }
 
@@ skipping 573 matching lines @@
       } else {
         for (ParameterElement parameter in targetOptionals) {
           loadPosition(position++, parameter);
         }
       }
     }
 
     ClassElement targetClass = targetConstructor.enclosingClass;
     if (rtiNeed.classNeedsRti(targetClass)) {
       ClassElement cls = redirectingConstructor.enclosingClass;
-      ResolutionInterfaceType targetType =
+      ResolutionDartType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
       targetType = localsHandler.substInContext(targetType);
-      targetType.typeArguments.forEach((ResolutionDartType argument) {
-        inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
-      });
+      if (targetType is ResolutionInterfaceType) {
+        targetType.typeArguments.forEach((ResolutionDartType argument) {
+          inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
+        });
+      }
     }
     pushInvokeStatic(node, targetConstructor.declaration, inputs);
     HInstruction value = pop();
     emitReturn(value, node);
   }
 
   /// Returns true if the [type] is a valid return type for an asynchronous
   /// function.
   ///
   /// Asynchronous functions return a `Future`, and a valid return is thus
@@ skipping 544 matching lines @@
       add(keyValuePairs);
       inputs.add(keyValuePairs);
     }
 
     assert(listConstructor.isFactoryConstructor);
 
     ConstructorElement constructorElement = listConstructor;
     listConstructor = constructorElement.effectiveTarget;
 
     ResolutionInterfaceType type = elements.getType(node);
-    ResolutionInterfaceType expectedType =
+    ResolutionDartType expectedType =
         constructorElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     ClassElement cls = listConstructor.enclosingClass;
 
     MethodElement createFunction = listConstructor;
-    if (rtiNeed.classNeedsRti(cls)) {
+    if (expectedType is ResolutionInterfaceType && rtiNeed.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
       expectedType.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
@@ skipping 1103 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }