All strong mode cleaning of dart2js.

pkg/compiler/lib/src/serialization/modelz.dart

 // Copyright (c) 2015, 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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 258 matching lines @@
 }
 
 abstract class AnalyzableElementMixin implements AnalyzableElement, ElementZ {
   @override
   bool get hasTreeElements => _unsupported('hasTreeElements');
 
   @override
   TreeElements get treeElements => _unsupported('treeElements');
 }
 
-abstract class AstElementMixinZ implements AstElement, ElementZ {
+abstract class AstElementMixinZ<N extends Node>
+    implements AstElement, ElementZ {
   ResolvedAst _resolvedAst;
 
   // TODO(johnniwinther): This is needed for the token invariant assertion. Find
   // another way to bypass the test for modelz.
   @override
   bool get hasNode => false;
 
   @override
   bool get hasResolvedAst => _resolvedAst != null;
 
   @override
-  get node => _unsupported('node');
+  N get node => _unsupported('node');
 
   @override
   ResolvedAst get resolvedAst {
     assert(_resolvedAst != null,
         failedAt(this, "ResolvedAst has not been set for $this."));
     return _resolvedAst;
   }
 
   void set resolvedAst(ResolvedAst value) {
     assert(_resolvedAst == null,
@@ skipping 90 matching lines @@
   @override
   bool get isInstanceMember => _canonicalElement.isInstanceMember;
 
   @override
   bool get isStatic => _canonicalElement.isStatic;
 
   @override
   bool get isTopLevel => _canonicalElement.isTopLevel;
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class LibraryElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, ContainerMixin, LibraryElementCommon
     implements LibraryElement {
   Uri _canonicalUri;
   CompilationUnitElement _entryCompilationUnit;
   Link<CompilationUnitElement> _compilationUnits;
   List<ImportElement> _imports;
   List<ExportElement> _exports;
   ListedContainer _exportsMap;
   ListedContainer _importsMap;
@@ skipping 341 matching lines @@
   @override
   bool get isTopLevel => false;
 
   @override
   bool get isStatic => true;
 
   @override
   bool get isClassMember => true;
 }
 
-abstract class TypedElementMixin implements DeserializedElementZ, TypedElement {
-  ResolutionDartType _type;
+abstract class TypedElementMixin<T extends ResolutionDartType>
+    implements DeserializedElementZ, TypedElement {
+  T _type;
 
   @override
-  ResolutionDartType get type {
+  T get type {
     if (_type == null) {
       _type = _decoder.getType(Key.TYPE);
     }
     return _type;
   }
 
   @override
-  ResolutionDartType computeType(Resolution resolution) => type;
+  T computeType(Resolution resolution) => type;
 }
 
 abstract class ParametersMixin
     implements DeserializedElementZ, FunctionTypedElement {
   FunctionSignature _functionSignature;
   List<ParameterElement> _parameters;
 
   bool get hasFunctionSignature => true;
 
   @override
@@ skipping 128 matching lines @@
       _isResolved = true;
       // TODO(johnniwinther): Avoid eager computation of all members. `call` is
       // always needed, but the remaining should be computed on-demand or on
       // type instantiation.
       class_members.MembersCreator.computeAllClassMembers(resolution, this);
       resolution.registerClass(this);
     }
   }
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class ClassElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixinZ,
         ClassElementCommon,
         class_members.ClassMemberMixin,
         ContainerMixin,
         LibraryMemberMixin,
-        TypeDeclarationMixin<ResolutionInterfaceType>,
+        TypeDeclarationMixin,
         ClassElementMixin
     implements ClassElement {
   bool _isObject;
   ResolutionInterfaceType _supertype;
   OrderedTypeSet _allSupertypesAndSelf;
   Link<ResolutionDartType> _interfaces;
   ResolutionFunctionType _callType;
 
   ClassElementZ(ObjectDecoder decoder) : super(decoder);
 
@@ skipping 70 matching lines @@
 
   @override
   bool get isUnnamedMixinApplication => false;
 
   @override
   ResolutionFunctionType get callType {
     _ensureSuperHierarchy();
     // TODO(johnniwinther): Why can't this always be computed in ensureResolved?
     return _callType;
   }
+
+  ResolutionInterfaceType get thisType => super.thisType;
+
+  ResolutionInterfaceType get rawType => super.rawType;
 }
 
 abstract class MixinApplicationElementMixin
     implements ElementZ, MixinApplicationElement {
   @override
   bool get isMixinApplication => true;
 
   @override
   ClassElement get mixin => mixinType.element;
 }
@@ skipping 11 matching lines @@
 
   @override
   ClassElement get subclass => null;
 }
 
 class UnnamedMixinApplicationElementZ extends ElementZ
     with
         ClassElementCommon,
         ClassElementMixin,
         class_members.ClassMemberMixin,
-        TypeDeclarationMixin<ResolutionInterfaceType>,
+        // ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_MIXIN
+        TypeDeclarationMixin,
         AnalyzableElementMixin,
         AstElementMixinZ,
         MixinApplicationElementCommon,
         MixinApplicationElementMixin {
   final String name;
   final ClassElement subclass;
   final ResolutionInterfaceType _supertypeBase;
   final ResolutionInterfaceType _mixinBase;
   ResolutionInterfaceType _supertype;
   Link<ResolutionDartType> _interfaces;
@@ skipping 130 matching lines @@
   @override
   ResolutionInterfaceType get mixinType => interfaces.head;
 
   @override
   int get sourceOffset => subclass.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => subclass.sourcePosition;
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
 
   EnumClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isEnumClass => true;
 
   @override
-  List<FieldElement> get enumValues {
+  List<EnumConstantElement> get enumValues {
     if (_enumValues == null) {
       _enumValues = _decoder.getElements(Key.FIELDS);
     }
     return _enumValues;
   }
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 abstract class ConstructorElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<FunctionExpression>,
         ClassMemberMixin,
         FunctionTypedElementMixin,
         ParametersMixin,
-        TypedElementMixin,
+        TypedElementMixin<ResolutionFunctionType>,
         MemberElementMixin,
         ConstructorElementCommon
     implements
         ConstructorElement,
         // TODO(johnniwinther): Sort out whether a constructor is a method.
         MethodElement {
   ConstantConstructor _constantConstructor;
   ConstructorElement _effectiveTarget;
 
   ConstructorElementZ(ObjectDecoder decoder) : super(decoder);
@@ skipping 59 matching lines @@
   @override
   bool get isRedirectingFactory => false;
 
   @override
   bool get isRedirectingGenerative => false;
 
   @override
   PrefixElement get redirectionDeferredPrefix => null;
 
   @override
-  ResolutionInterfaceType computeEffectiveTargetType(
+  ResolutionDartType computeEffectiveTargetType(
           ResolutionInterfaceType newType) =>
       newType;
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
   GenerativeConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
@@ skipping 89 matching lines @@
     return _immediateRedirectionTarget;
   }
 
   @override
   PrefixElement get redirectionDeferredPrefix {
     _ensureRedirection();
     return _redirectionDeferredPrefix;
   }
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class ForwardingConstructorElementZ extends ElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ
+        AstElementMixinZ<FunctionExpression>
     implements
         ConstructorElement,
         // TODO(johnniwinther): Sort out whether a constructor is a method.
         MethodElement {
   final MixinApplicationElement enclosingClass;
   final ConstructorElement definingConstructor;
 
   ForwardingConstructorElementZ(this.enclosingClass, this.definingConstructor);
 
   @override
   CompilationUnitElement get compilationUnit => enclosingClass.compilationUnit;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   @override
   AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 
   @override
-  ResolutionInterfaceType computeEffectiveTargetType(
+  ResolutionDartType computeEffectiveTargetType(
       ResolutionInterfaceType newType) {
     return enclosingClass.thisType.substByContext(newType);
   }
 
   @override
   ResolutionDartType computeType(Resolution resolution) => type;
 
   @override
   bool get isConst => false;
 
@@ skipping 121 matching lines @@
   @override
   Name get memberName => new Name(name, library);
 
   @override
   bool get isInjected => _decoder.getBool(Key.IS_INJECTED);
 }
 
 abstract class FieldElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<VariableDefinitions>,
         TypedElementMixin,
         MemberElementMixin
     implements FieldElement {
   bool _isConst;
   ConstantExpression _constant;
 
   FieldElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FIELD;
@@ skipping 34 matching lines @@
 
 class TopLevelFieldElementZ extends FieldElementZ with LibraryMemberMixin {
   TopLevelFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticFieldElementZ extends FieldElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class EnumConstantElementZ extends StaticFieldElementZ
     implements EnumConstantElement {
   EnumConstantElementZ(ObjectDecoder decoder) : super(decoder);
 
   int get index => _decoder.getInt(Key.INDEX);
 }
 
 class InstanceFieldElementZ extends FieldElementZ
     with ClassMemberMixin, InstanceMemberMixin {
   InstanceFieldElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 abstract class FunctionElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<FunctionExpression>,
         ParametersMixin,
         FunctionTypedElementMixin,
-        TypedElementMixin,
+        TypedElementMixin<ResolutionFunctionType>,
         MemberElementMixin
     implements MethodElement {
   FunctionElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
@@ skipping 27 matching lines @@
 }
 
 abstract class LocalExecutableMixin
     implements DeserializedElementZ, ExecutableElement, LocalElement {
   ExecutableElement _executableContext;
 
   @override
   Element get enclosingElement => executableContext;
 
   @override
-  Element get enclosingClass => memberContext.enclosingClass;
+  ClassElementZ get enclosingClass => memberContext.enclosingClass;
 
   @override
   ExecutableElement get executableContext {
     if (_executableContext == null) {
       _executableContext = _decoder.getElement(Key.EXECUTABLE_CONTEXT);
     }
     return _executableContext;
   }
 
   @override
@@ skipping 10 matching lines @@
     return memberContext.compilationUnit;
   }
 
   @override
   bool get hasTreeElements => memberContext.hasTreeElements;
 
   @override
   TreeElements get treeElements => memberContext.treeElements;
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 class LocalFunctionElementZ extends DeserializedElementZ
     with
         LocalExecutableMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<FunctionExpression>,
         ParametersMixin,
         FunctionTypedElementMixin,
-        TypedElementMixin
+        TypedElementMixin<ResolutionFunctionType>
     implements LocalFunctionElement {
   LocalFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLocalFunctionElement(this, arg);
   }
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   AsyncMarker get asyncMarker {
     return _decoder.getEnum(Key.ASYNC_MARKER, AsyncMarker.values);
   }
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 abstract class GetterElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<FunctionExpression>,
         FunctionTypedElementMixin,
         ParametersMixin,
-        TypedElementMixin,
+        TypedElementMixin<ResolutionFunctionType>,
         MemberElementMixin
     implements GetterElement {
   AbstractFieldElement abstractField;
   SetterElement setter;
 
   GetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GETTER;
 
@@ skipping 18 matching lines @@
 class StaticGetterElementZ extends GetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceGetterElementZ extends GetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
   InstanceGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
+// ignore: STRONG_MODE_INVALID_METHOD_OVERRIDE_FROM_BASE
 abstract class SetterElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<FunctionExpression>,
         FunctionTypedElementMixin,
         ParametersMixin,
-        TypedElementMixin,
+        TypedElementMixin<ResolutionFunctionType>,
         MemberElementMixin
     implements SetterElement {
   AbstractFieldElement abstractField;
   GetterElement getter;
 
   SetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.SETTER;
 
@@ skipping 16 matching lines @@
 class StaticSetterElementZ extends SetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceSetterElementZ extends SetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
   InstanceSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
-abstract class TypeDeclarationMixin<T extends GenericType>
+abstract class TypeDeclarationMixin
     implements ElementZ, TypeDeclarationElement {
   List<ResolutionDartType> _typeVariables;
-  T _rawType;
-  T _thisType;
+  GenericType _rawType;
+  GenericType _thisType;
   Name _memberName;
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
 
   List<ResolutionDartType> _getTypeVariables();
 
   void _ensureTypes() {
     if (_typeVariables == null) {
       _typeVariables = _getTypeVariables();
       _rawType = _createType(new List<ResolutionDartType>.filled(
           _typeVariables.length, const ResolutionDynamicType()));
       _thisType = _createType(_typeVariables);
     }
   }
 
-  T _createType(List<ResolutionDartType> typeArguments);
+  GenericType _createType(List<ResolutionDartType> typeArguments);
 
   @override
   List<ResolutionDartType> get typeVariables {
     _ensureTypes();
     return _typeVariables;
   }
 
   @override
-  T get rawType {
+  GenericType get rawType {
     _ensureTypes();
     return _rawType;
   }
 
   @override
-  T get thisType {
+  GenericType get thisType {
     _ensureTypes();
     return _thisType;
   }
 
   @override
-  T computeType(Resolution resolution) => thisType;
+  GenericType computeType(Resolution resolution) => thisType;
 
   @override
   bool get isResolved => true;
 }
 
 class TypedefElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<Node>,
         LibraryMemberMixin,
         ParametersMixin,
-        TypeDeclarationMixin<ResolutionTypedefType>
+        TypeDeclarationMixin
     implements TypedefElement {
   ResolutionDartType _alias;
 
   TypedefElementZ(ObjectDecoder decoder) : super(decoder);
 
   ResolutionTypedefType _createType(List<ResolutionDartType> typeArguments) {
     return new ResolutionTypedefType(this, typeArguments);
   }
 
   @override
@@ skipping 15 matching lines @@
       _alias = _decoder.getType(Key.ALIAS);
     }
     return _alias;
   }
 
   @override
   void ensureResolved(Resolution resolution) {}
 
   @override
   void checkCyclicReference(Resolution resolution) {}
+
+  ResolutionTypedefType get thisType => super.thisType;
+
+  ResolutionTypedefType get rawType => super.rawType;
 }
 
 class TypeVariableElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin, AstElementMixinZ, TypedElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixinZ<Node>,
+        TypedElementMixin<ResolutionTypeVariableType>
     implements TypeVariableElement {
   GenericElement _typeDeclaration;
   ResolutionTypeVariableType _type;
   ResolutionDartType _bound;
   Name _memberName;
 
   TypeVariableElementZ(ObjectDecoder decoder) : super(decoder);
 
   Name get memberName {
     if (_memberName == null) {
@@ skipping 12 matching lines @@
 
   @override
   CompilationUnitElement get compilationUnit {
     return typeDeclaration.compilationUnit;
   }
 
   @override
   Element get enclosingElement => typeDeclaration;
 
   @override
-  Element get enclosingClass => typeDeclaration;
+  ClassElementZ get enclosingClass => typeDeclaration;
 
   @override
   int get index => _decoder.getInt(Key.INDEX);
 
   @override
   GenericElement get typeDeclaration {
     if (_typeDeclaration == null) {
       _typeDeclaration = _decoder.getElement(Key.TYPE_DECLARATION);
     }
     return _typeDeclaration;
   }
 
   ResolutionDartType get bound {
     if (_bound == null) {
       _bound = _decoder.getType(Key.BOUND);
     }
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 }
 
 class SyntheticTypeVariableElementZ extends ElementZ
-    with AnalyzableElementMixin, AstElementMixinZ
+    with AnalyzableElementMixin, AstElementMixinZ<Node>
     implements TypeVariableElement {
   final TypeDeclarationElement typeDeclaration;
   final int index;
   final String name;
   ResolutionTypeVariableType _type;
   ResolutionDartType _bound;
   Name _memberName;
 
   SyntheticTypeVariableElementZ(this.typeDeclaration, this.index, this.name);
 
@@ skipping 24 matching lines @@
     return _type;
   }
 
   @override
   ResolutionTypeVariableType computeType(Resolution resolution) => type;
 
   @override
   Element get enclosingElement => typeDeclaration;
 
   @override
-  Element get enclosingClass => typeDeclaration;
+  ClassElementZ get enclosingClass => typeDeclaration;
 
   ResolutionDartType get bound {
     assert(_bound != null,
         failedAt(this, "Type variable bound has not been set on $this."));
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 
   @override
   int get sourceOffset => typeDeclaration.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
 }
 
 abstract class ParameterElementZ extends DeserializedElementZ
-    with AnalyzableElementMixin, AstElementMixinZ, TypedElementMixin
+    with
+        AnalyzableElementMixin,
+        AstElementMixinZ<VariableDefinitions>,
+        TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
   ResolutionDartType _type;
 
   ParameterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isFinal => _decoder.getBool(Key.IS_FINAL);
 
@@ skipping 35 matching lines @@
 
   @override
   FunctionSignature get functionSignature => _unsupported('functionSignature');
 
   // TODO(johnniwinther): Remove [initializer] and [node] on
   // [ParameterElementZ] when the inference does need these.
   @override
   Expression initializer;
 
   @override
-  Node node;
+  VariableDefinitions node;
 
   @override
   bool get isNamed => _decoder.getBool(Key.IS_NAMED);
 
   @override
   bool get isOptional => _decoder.getBool(Key.IS_OPTIONAL);
 
   @override
   LibraryElement get library => executableContext.library;
 
@@ skipping 40 matching lines @@
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFieldParameterElement(this, arg);
   }
 
   @override
   ElementKind get kind => ElementKind.INITIALIZING_FORMAL;
 
   @override
   bool get isLocal => true;
+
+  ConstructorElementZ get functionDeclaration => super.functionDeclaration;
 }
 
 class LocalVariableElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
-        AstElementMixinZ,
+        AstElementMixinZ<VariableDefinitions>,
         LocalExecutableMixin,
         TypedElementMixin
     implements LocalVariableElement {
   bool _isConst;
   ConstantExpression _constant;
 
   LocalVariableElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) {
@@ skipping 210 matching lines @@
   }
 
   @override
   Node get node => throw new UnsupportedError('${this}.node');
 
   @override
   bool get hasNode => false;
 
   String toString() => 'MetadataAnnotationZ(${constant.toDartText()})';
 }