All strong mode cleaning of dart2js.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
@@ skipping 232 matching lines @@
   Iterable<MetadataAnnotation> get metadata => unsupported();
   bool get hasNode => false;
   get node => unsupported();
   get hasResolvedAst => false;
   get resolvedAst => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get parameterStructure => unsupported();
   get parameters => unsupported();
-  get patch => null;
-  get origin => this;
+  Element get patch => null;
+  Element get origin => this;
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
   get constantConstructor => null;
 
   bool get isRedirectingGenerative => unsupported();
   bool get isRedirectingFactory => unsupported();
 
@@ skipping 109 matching lines @@
   set _isEffectiveTargetMalformed(_) {
     throw new UnsupportedError("_isEffectiveTargetMalformed=");
   }
 
   @override
   get isEffectiveTargetMalformed {
     throw new UnsupportedError("isEffectiveTargetMalformed");
   }
 
   @override
-  void setEffectiveTarget(
-      ConstructorElement target, ResolutionInterfaceType type,
+  void setEffectiveTarget(ConstructorElement target, ResolutionDartType type,
       {bool isMalformed: false}) {
     throw new UnsupportedError("setEffectiveTarget");
   }
 
   @override
   void _computeSignature(Resolution resolution) {
     throw new UnsupportedError("_computeSignature");
   }
 
   @override
@@ skipping 58 matching lines @@
 
   @override
   get _redirectionDeferredPrefix {
     throw new UnsupportedError("_redirectionDeferredPrefix");
   }
 
   @override
   set _redirectionDeferredPrefix(_) {
     throw new UnsupportedError("_redirectionDeferredPrefix=");
   }
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get declaration => super.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get implementation => super.implementation;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get origin => super.origin;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get patch => super.patch;
+
+  ResolutionFunctionType computeType(Resolution resolution) =>
+      super.computeType(resolution);
 }
 
 /// A message attached to a [WarnOnUseElementX].
 class WrappedMessage {
   /// The message position. If [:null:] the position of the reference to the
   /// [WarnOnUseElementX] is used.
   final SourceSpan sourceSpan;
 
   /**
    * The message to report on resolving a wrapped element.
@@ skipping 333 matching lines @@
               {'libraryName': actualName}),
           <DiagnosticMessage>[
             reporter.createMessage(
                 tag.name, MessageKind.THIS_IS_THE_PART_OF_TAG),
           ]);
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
-  Element get analyzableElement => library;
+  AnalyzableElement get analyzableElement => library;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
 }
 
 /// Map from [Element] to the [ImportElement]s throught which it was imported.
 ///
 /// This is used for error reporting and deferred loading.
 class Importers {
@@ skipping 241 matching lines @@
     return const <MetadataAnnotation>[];
   }
 
   void set metadata(value) {
     // The metadata is stored on [libraryTag].
     throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
   }
 
   CompilationUnitElement get compilationUnit => entryCompilationUnit;
 
-  Element get analyzableElement => this;
+  AnalyzableElement get analyzableElement => this;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticReporter reporter) {
     if (tagsCache != null) {
       reporter.internalError(
           tag, "Library tags for $this have already been computed.");
     }
@@ skipping 167 matching lines @@
       return 'origin library(${canonicalUri})';
     } else {
       return 'library(${canonicalUri})';
     }
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLibraryElement(this, arg);
   }
 
-  // TODO(johnniwinther): Remove these when issue 18630 is fixed.
+  // TODO(johnniwinther): Remove this.
+  LibraryElementX get declaration => super.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  LibraryElementX get implementation => super.implementation;
+
+  // TODO(johnniwinther): Remove this.
+  LibraryElementX get origin => super.origin;
+
+  // TODO(johnniwinther): Remove this.
   LibraryElementX get patch => super.patch;
-  LibraryElementX get origin => super.origin;
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
   bool get isDeferred => deferredImport != null;
 
   // Only needed for deferred imports.
@@ skipping 25 matching lines @@
 
   @override
   GetterElement get loadLibrary {
     return isDeferred ? lookupLocalMember(Identifiers.loadLibrary) : null;
   }
 
   String toString() => '$kind($name)';
 }
 
 class TypedefElementX extends ElementX
-    with
-        AstElementMixin,
-        AnalyzableElementX,
-        TypeDeclarationElementX<ResolutionTypedefType>
+    with AstElementMixin, AnalyzableElementX, TypeDeclarationElementX
     implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type annotation which defines this typedef.
    */
   ResolutionDartType aliasCache;
 
   ResolutionDartType get alias {
     assert(hasBeenCheckedForCycles,
@@ skipping 56 matching lines @@
     computeType(resolution).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
+
+  ResolutionTypedefType get thisType => super.thisType;
+
+  ResolutionTypedefType get rawType => super.rawType;
 }
 
 // This class holds common information for a list of variable or field
 // declarations. It contains the node, and the type. A [VariableElementX]
 // forwards its [computeType] and [parseNode] methods to this class.
 class VariableList implements DeclarationSite {
   VariableDefinitions definitions;
   ResolutionDartType type;
   final Modifiers modifiers;
   List<MetadataAnnotation> metadataInternal;
@@ skipping 495 matching lines @@
     return visitor.visitFieldParameterElement(this, arg);
   }
 
   MemberElement get memberContext => enclosingElement;
 
   @override
   bool get isFinal => true;
 
   @override
   bool get isLocal => true;
+
+  ConstructorElement get functionDeclaration => super.functionDeclaration;
 }
 
 class ErroneousInitializingFormalElementX extends ParameterElementX
     implements InitializingFormalElementX {
   final ErroneousFieldElementX fieldElement;
 
   ErroneousInitializingFormalElementX(
       Identifier identifier, Element enclosingElement)
       : this.fieldElement =
             new ErroneousFieldElementX(identifier, enclosingElement),
         super(ElementKind.INITIALIZING_FORMAL, enclosingElement, null,
             identifier, null);
 
   VariableDefinitions get definitions => fieldElement.node;
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 
   bool get isMalformed => true;
 
   ResolutionDynamicType get type => const ResolutionDynamicType();
+
+  ConstructorElement get functionDeclaration => super.functionDeclaration;
 }
 
 class AbstractFieldElementX extends ElementX
     with AbstractFieldElementCommon
     implements AbstractFieldElement {
   GetterElementX getter;
   SetterElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
@@ skipping 34 matching lines @@
     }
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAbstractFieldElement(this, arg);
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
-// TODO(karlklose): all these lists should have element type [FormalElement].
 class FunctionSignatureX extends FunctionSignatureCommon
     implements FunctionSignature {
   final List<ResolutionDartType> typeVariables;
-  final List<Element> requiredParameters;
-  final List<Element> optionalParameters;
+  final List<FormalElement> requiredParameters;
+  final List<FormalElement> optionalParameters;
   final int requiredParameterCount;
   final int optionalParameterCount;
   final bool optionalParametersAreNamed;
-  final List<Element> orderedOptionalParameters;
+  final List<FormalElement> orderedOptionalParameters;
   final ResolutionFunctionType type;
   final bool hasOptionalParameters;
 
   FunctionSignatureX(
       {this.typeVariables: const <ResolutionDartType>[],
-      this.requiredParameters: const <Element>[],
+      this.requiredParameters: const <FormalElement>[],
       this.requiredParameterCount: 0,
-      List<Element> optionalParameters: const <Element>[],
+      List<Element> optionalParameters: const <FormalElement>[],
       this.optionalParameterCount: 0,
       this.optionalParametersAreNamed: false,
-      this.orderedOptionalParameters: const <Element>[],
+      this.orderedOptionalParameters: const <FormalElement>[],
       this.type})
       : optionalParameters = optionalParameters,
         hasOptionalParameters = !optionalParameters.isEmpty;
 }
 
 abstract class BaseFunctionElementX extends ElementX
     with PatchMixin<FunctionElement>, AstElementMixin
     implements FunctionElement {
   ResolutionDartType typeCache;
   final Modifiers modifiers;
@@ skipping 80 matching lines @@
     }
   }
 
   bool get isAbstract => false;
 
   // A function is defined by the implementation element.
   AstElement get definingElement => implementation;
 
   @override
   List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
+
+  // TODO(johnniwinther): Remove this.
+  FunctionElement get declaration => super.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  FunctionElement get implementation => super.implementation;
+
+  // TODO(johnniwinther): Remove this.
+  FunctionElement get origin => super.origin;
+
+  // TODO(johnniwinther): Remove this.
+  FunctionElement get patch => super.patch;
 }
 
 abstract class FunctionElementX extends BaseFunctionElementX
     with AnalyzableElementX
     implements MethodElement {
   FunctionElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
 
   MemberElement get memberContext => this;
@@ skipping 155 matching lines @@
     implements ConstructorElement {
   bool isRedirectingGenerativeInternal = false;
 
   ConstructorElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
 
   ConstructorElement _immediateRedirectionTarget;
   PrefixElement _redirectionDeferredPrefix;
 
-  ConstructorElementX get patch => super.patch;
-
   bool get isRedirectingGenerative {
     if (isPatched) return patch.isRedirectingGenerative;
     return isRedirectingGenerativeInternal;
   }
 
   bool get isRedirectingFactory => immediateRedirectionTarget != null;
 
   // TODO(johnniwinther): This should also return true for cyclic redirecting
   // generative constructors.
   bool get isCyclicRedirection => effectiveTarget.isRedirectingFactory;
@@ skipping 110 matching lines @@
     return _isEffectiveTargetMalformed == true;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   ConstructorElement get definingConstructor => null;
 
   ClassElement get enclosingClass => enclosingElement.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get declaration => super.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get implementation => super.implementation;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get origin => super.origin;
+
+  // TODO(johnniwinther): Remove this.
+  ConstructorElementX get patch => super.patch;
 }
 
-class DeferredLoaderGetterElementX extends GetterElementX
-    implements GetterElement {
+class DeferredLoaderGetterElementX extends GetterElementX {
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super(Identifiers.loadLibrary, Modifiers.EMPTY, prefix, false) {
     functionSignature =
         new FunctionSignatureX(type: new ResolutionFunctionType(this));
   }
 
   bool get isClassMember => false;
@@ skipping 105 matching lines @@
     reporter.internalError(this, '$this.computeType.');
     return null;
   }
 
   int get sourceOffset => constructor.sourceOffset;
 
   Token get position => constructor.position;
 
   Element get outermostEnclosingMemberOrTopLevel => constructor;
 
-  Element get analyzableElement => constructor.analyzableElement;
+  AnalyzableElement get analyzableElement => constructor.analyzableElement;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorBodyElement(this, arg);
   }
 
   MemberElement get memberContext => constructor;
 }
 
 /**
  * A constructor that is not defined in the source code but rather implied by
@@ skipping 35 matching lines @@
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   bool get hasResolvedAst => true;
 
   ResolvedAst get resolvedAst => _resolvedAst;
 
-  ResolutionDartType get type {
+  ResolutionFunctionType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
   void _computeSignature(Resolution resolution) {
     if (hasFunctionSignature) return;
     if (definingConstructor.isMalformed) {
       functionSignature = new FunctionSignatureX(
           type:
               new ResolutionFunctionType.synthesized(enclosingClass.thisType));
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     definingConstructor.computeType(resolution);
     functionSignature = definingConstructor.functionSignature;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 }
 
-abstract class TypeDeclarationElementX<T extends GenericType>
-    implements TypeDeclarationElement {
+abstract class TypeDeclarationElementX implements TypeDeclarationElement {
   /**
    * The `this type` for this type declaration.
    *
    * The type of [:this:] is the generic type based on this element in which
    * the type arguments are the declared type variables. For instance,
    * [:List<E>:] for [:List:] and [:Map<K,V>:] for [:Map:].
    *
    * For a class declaration this is the type of [:this:].
    *
    * This type is computed in [computeType].
    */
-  T thisTypeCache;
+  GenericType thisTypeCache;
 
   /**
    * The raw type for this type declaration.
    *
    * The raw type is the generic type base on this element in which the type
    * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
    * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
    * is the same as [thisType].
    *
    * The [rawType] field is a canonicalization of the raw type and should be
    * used to distinguish explicit and implicit uses of the [dynamic]
    * type arguments. For instance should [:List:] be the [rawType] of the
    * [:List:] class element whereas [:List<dynamic>:] should be its own
    * instantiation of [ResolutionInterfaceType] with [:dynamic:] as type
    * argument. Using this distinction, we can print the raw type with type
    * arguments only when the input source has used explicit type arguments.
    *
    * This type is computed together with [thisType] in [computeType].
    */
-  T rawTypeCache;
+  GenericType rawTypeCache;
 
-  T get thisType {
+  GenericType get thisType {
     assert(thisTypeCache != null,
         failedAt(this, 'This type has not been computed for $this'));
     return thisTypeCache;
   }
 
-  T get rawType {
+  GenericType get rawType {
     assert(rawTypeCache != null,
         failedAt(this, 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
-  T createType(List<ResolutionDartType> typeArguments);
+  GenericType createType(List<ResolutionDartType> typeArguments);
 
   void setThisAndRawTypes(List<ResolutionDartType> typeParameters) {
     assert(thisTypeCache == null,
         failedAt(this, "This type has already been set on $this."));
     assert(rawTypeCache == null,
         failedAt(this, "Raw type has already been set on $this."));
     thisTypeCache = createType(typeParameters);
     if (typeParameters.isEmpty) {
       rawTypeCache = thisTypeCache;
     } else {
@@ skipping 33 matching lines @@
   bool get isResolved => resolutionState == STATE_DONE;
 
   int get resolutionState;
 }
 
 abstract class BaseClassElementX extends ElementX
     with
         AstElementMixin,
         AnalyzableElementX,
         ClassElementCommon,
-        TypeDeclarationElementX<ResolutionInterfaceType>,
+        TypeDeclarationElementX,
         PatchMixin<ClassElement>,
         ClassMemberMixin
     implements ClassElement {
   final int id;
 
   ResolutionInterfaceType supertype;
   Link<ResolutionDartType> interfaces;
   int supertypeLoadState;
   int resolutionState;
   bool isProxy = false;
@@ skipping 77 matching lines @@
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass {
     assert(supertypeLoadState == STATE_DONE,
         failedAt(this, "Superclass has not been computed for $this."));
     return supertype == null ? null : supertype.element;
   }
 
-  // TODO(johnniwinther): Remove these when issue 18630 is fixed.
-  ClassElement get patch => super.patch;
+  // A class declaration is defined by the declaration element.
+  AstElement get definingElement => declaration;
+
+  ResolutionInterfaceType get thisType => super.thisType;
+
+  ResolutionInterfaceType get rawType => super.rawType;
+
+  // TODO(johnniwinther): Remove this.
+  ClassElement get declaration => super.declaration;
+
+  // TODO(johnniwinther): Remove this.
+  ClassElement get implementation => super.implementation;
+
+  // TODO(johnniwinther): Remove this.
   ClassElement get origin => super.origin;
 
-  // A class declaration is defined by the declaration element.
-  AstElement get definingElement => declaration;
+  // TODO(johnniwinther): Remove this.
+  ClassElement get patch => super.patch;
 }
 
 abstract class ClassElementX extends BaseClassElementX {
   Link<Element> localMembersReversed = const Link<Element>();
   final ScopeX localScope = new ScopeX();
 
   Link<Element> localMembersCache;
 
   Link<Element> get localMembers {
     if (localMembersCache == null) {
@@ skipping 86 matching lines @@
 ///       static const A c = const A(1);
 ///
 ///       static const List<A> values = const <A>[b, c];
 ///     }
 ///
 ///  where the `A` class is encoded using this element.
 ///
 class EnumClassElementX extends ClassElementX
     implements EnumClassElement, DeclarationSite {
   final Enum node;
-  List<FieldElement> _enumValues;
+  List<EnumConstantElement> _enumValues;
 
   EnumClassElementX(String name, Element enclosing, int id, this.node)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   @override
   bool get hasNode => true;
 
   @override
   Token get position => node.name.token;
 
   @override
   bool get isEnumClass => true;
 
   @override
   Node parseNode(ParsingContext parsing) => node;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitEnumClassElement(this, arg);
   }
 
   List<ResolutionDartType> computeTypeParameters(ParsingContext parsing) =>
       const <ResolutionDartType>[];
 
-  List<FieldElement> get enumValues {
+  List<EnumConstantElement> get enumValues {
     assert(_enumValues != null,
         failedAt(this, "enumValues has not been computed for $this."));
     return _enumValues;
   }
 
-  void set enumValues(List<FieldElement> values) {
+  void set enumValues(List<EnumConstantElement> values) {
     assert(_enumValues == null,
         failedAt(this, "enumValues has already been computed for $this."));
     _enumValues = values;
   }
 
   @override
   DeclarationSite get declarationSite => this;
 }
 
 /// This element is used to encode the implicit constructor in an enum class.
@@ skipping 200 matching lines @@
       Node definition,
       Expression initializer,
       this.index)
       : super(name, enumClass, variableList, definition, initializer);
 
   @override
   SourceSpan get sourcePosition {
     return new SourceSpan(enclosingClass.sourcePosition.uri,
         position.charOffset, position.charEnd);
   }
+
+  EnumClassElement get enclosingClass => super.enclosingClass;
 }
 
 abstract class MixinApplicationElementX extends BaseClassElementX
     with MixinApplicationElementCommon
     implements MixinApplicationElement {
   Link<ConstructorElement> constructors = new Link<ConstructorElement>();
 
   ResolutionInterfaceType mixinType;
 
   MixinApplicationElementX(String name, Element enclosing, int id)
@@ skipping 256 matching lines @@
 
   Token get endToken => metadata.getEndToken();
 
   bool get hasNode => true;
 
   Metadata get node => metadata;
 }
 
 /// Mixin for the implementation of patched elements.
 ///
-/// See [:patch_parser.dart:] for a description of the terminology.
+/// See `patch_parser.dart` for a description of the terminology.
 abstract class PatchMixin<E extends Element> implements Element {
-  // TODO(johnniwinther): Use type variables when issue 18630 is fixed.
-  Element /*E*/ patch = null;
-  Element /*E*/ origin = null;
+  // TODO(johnniwinther): Use type variables.
+  Element /* E */ patch = null;
+  Element /* E */ origin = null;
 
   bool get isPatch => origin != null;
   bool get isPatched => patch != null;
 
   bool get isImplementation => !isPatched;
   bool get isDeclaration => !isPatch;
 
-  Element /*E*/ get implementation => isPatched ? patch : this;
-  Element /*E*/ get declaration => isPatch ? origin : this;
+  Element /* E */ get implementation => isPatched ? patch : this;
+  Element /* E */ get declaration => isPatch ? origin : this;
 
   /// Applies a patch to this element. This method must be called at most once.
   void applyPatch(PatchMixin<E> patch) {
     assert(this.patch == null, failedAt(this, "Element is patched twice."));
     assert(this.origin == null, failedAt(this, "Origin element is a patch."));
     assert(patch.origin == null, failedAt(patch, "Element is patched twice."));
     assert(patch.patch == null, failedAt(patch, "Patch element is patched."));
     this.patch = patch;
     patch.origin = this;
   }
@@ skipping 25 matching lines @@
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration,
         node,
         body,
         definingElement.treeElements,
         definingElement.compilationUnit.script.resourceUri);
   }
 }