All strong mode cleaning of dart2js.

pkg/compiler/lib/src/closure.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 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
@@ skipping 23 matching lines @@
 
 /// Class that provides information for how closures are rewritten/represented
 /// to preserve Dart semantics when compiled to JavaScript. Given a particular
 /// node to look up, it returns a information about the internal representation
 /// of how closure conversion is implemented. T is an ir.Node or Node.
 abstract class ClosureDataLookup<T> {
   /// Look up information about the variables that have been mutated and are
   /// used inside the scope of [node].
   // TODO(johnniwinther): Split this up into two functions, one for members and
   // one for local functions.
-  ClosureRepresentationInfo getClosureRepresentationInfo(Entity member);
+  ClosureRepresentationInfo getClosureRepresentationInfo(
+      covariant Entity member);
 
   /// Look up information about a loop, in case any variables it declares need
   /// to be boxed/snapshotted.
   LoopClosureRepresentationInfo getClosureRepresentationInfoForLoop(T loopNode);
 
   /// Accessor to the information about closures that the SSA builder will use.
   ClosureAnalysisInfo getClosureAnalysisInfo(T node);
 }
 
 /// Class that provides a black-box interface to information gleaned from
@@ skipping 290 matching lines @@
   MemberElement get memberContext => closureClass.methodElement.memberContext;
 
   @override
   Local get declaredEntity => local;
 
   @override
   Entity get rootOfScope => closureClass;
 
   bool get hasNode => false;
 
-  Node get node {
+  VariableDefinitions get node {
     throw new SpannableAssertionFailure(
         local, 'Should not access node of ClosureFieldElement.');
   }
 
   bool get hasResolvedAst => hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ParsedResolvedAst(this, null, null, treeElements,
         memberContext.compilationUnit.script.resourceUri);
   }
@@ skipping 15 matching lines @@
     }
     return const ResolutionDynamicType();
   }
 
   String toString() => "ClosureFieldElement($name)";
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClosureFieldElement(this, arg);
   }
 
-  Element get analyzableElement => closureClass.methodElement.analyzableElement;
+  AnalyzableElement get analyzableElement =>
+      closureClass.methodElement.analyzableElement;
 
   @override
   List<FunctionElement> get nestedClosures => const <FunctionElement>[];
 
   @override
   bool get hasConstant => false;
 
   @override
   ConstantExpression get constant => null;
 }
@@ skipping 118 matching lines @@
     throw new UnsupportedError("BoxFieldElement.initializer");
   }
 
   @override
   MemberElement get memberContext => box.executableContext.memberContext;
 
   @override
   List<FunctionElement> get nestedClosures => const <FunctionElement>[];
 
   @override
-  Node get node {
+  VariableDefinitions get node {
     throw new UnsupportedError("BoxFieldElement.node");
   }
 
   @override
   ResolvedAst get resolvedAst {
     throw new UnsupportedError("BoxFieldElement.resolvedAst");
   }
 
   @override
   bool get hasConstant => false;
@@ skipping 10 matching lines @@
   ThisLocal(this.memberContext);
 
   Entity get executableContext => memberContext;
 
   String get name => 'this';
 
   ClassEntity get enclosingClass => memberContext.enclosingClass;
 }
 
 /// Call method of a closure class.
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class SynthesizedCallMethodElementX extends BaseFunctionElementX
     implements MethodElement {
   final LocalFunctionElement expression;
   final FunctionExpression node;
   final TreeElements treeElements;
 
   SynthesizedCallMethodElementX(String name, LocalFunctionElement other,
       ClosureClassElement enclosing, this.node, this.treeElements)
       : expression = other,
         super(name, other.kind, Modifiers.EMPTY, enclosing) {
     asyncMarker = other.asyncMarker;
     functionSignature = other.functionSignature;
   }
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
 
   ClosureClassElement get closureClass => super.enclosingElement;
 
   MemberElement get memberContext {
     return closureClass.methodElement.memberContext;
   }
 
   bool get hasNode => node != null;
 
   FunctionExpression parseNode(ParsingContext parsing) => node;
 
-  Element get analyzableElement => closureClass.methodElement.analyzableElement;
+  AnalyzableElement get analyzableElement =>
+      closureClass.methodElement.analyzableElement;
 
   bool get hasResolvedAst => true;
 
   ResolvedAst get resolvedAst {
     return new ParsedResolvedAst(this, node, node.body, treeElements,
         expression.compilationUnit.script.resourceUri);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
@@ skipping 862 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements MemberEntity {
   Local get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }