All strong mode cleaning of dart2js.

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 856 matching lines @@
 /// or otherwise invalid.
 ///
 /// Accessing any field or calling any method defined on [ErroneousElement]
 /// except [isError] will currently throw an exception. (This might
 /// change when we actually want more information on the erroneous element,
 /// e.g., the name of the element we were trying to resolve.)
 ///
 /// Code that cannot not handle an [ErroneousElement] should use
 /// `Element.isUnresolved(element)` to check for unresolvable elements instead
 /// of `element == null`.
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 abstract class ErroneousElement extends Element implements ConstructorElement {
   MessageKind get messageKind;
   Map get messageArguments;
   String get message;
 }
 
 /// An [Element] whose usage should cause one or more warnings.
 abstract class WarnOnUseElement extends Element {
   /// The element whose usage cause a warning.
   Element get wrappedElement;
@@ skipping 445 matching lines @@
   ///       - it is part of a redirection cycle,
   ///       - the effective target is a generative constructor on an abstract
   ///         class, or
   ///       - this constructor is constant but the effective target is not,
   ///       - the arguments to this constructor are incompatible with the
   ///         parameters of the effective target.
   bool get isEffectiveTargetMalformed;
 
   /// Compute the type of the effective target of this constructor for an
   /// instantiation site with type [:newType:].
-  ResolutionInterfaceType computeEffectiveTargetType(
+  /// May return a malformed type.
+  ResolutionDartType computeEffectiveTargetType(
       ResolutionInterfaceType newType);
 
   /// If this is a synthesized constructor [definingConstructor] points to
   /// the generative constructor from which this constructor was created.
   /// Otherwise [definingConstructor] is `null`.
   ///
   /// Consider for instance this hierarchy:
   ///
   ///     class C { C.c(a, {b});
   ///     class D {}
@@ skipping 517 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }