Make analyzer strong-mode clean

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 329 matching lines @@
  * during linking.
  */
 abstract class ClassElementForLink extends Object
     with ReferenceableElementForLink
     implements AbstractClassElementImpl {
   Map<String, ReferenceableElementForLink> _containedNames;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
 
-  @override
+  /// TODO(brianwilkerson) This appears to be unused and might be removable.
   bool hasBeenInferred;
 
   ClassElementForLink(CompilationUnitElementForLink enclosingElement)
       : enclosingElement = enclosingElement,
         hasBeenInferred = !enclosingElement.isInBuildUnit;
 
   @override
   List<PropertyAccessorElementForLink> get accessors;
 
   @override
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
   @override
   DartType get asStaticType =>
       enclosingElement.enclosingElement._linker.typeProvider.typeType;
 
   @override
   List<ConstructorElementForLink> get constructors;
 
   @override
-  CompilationUnitElementForLink get enclosingUnit => enclosingElement;
+  CompilationUnitElementImpl get enclosingUnit => enclosingElement;
 
   @override
   List<FieldElementForLink> get fields;
 
   /**
    * Indicates whether this is the core class `Object`.
    */
   bool get isObject;
 
   @override
@@ skipping 182 matching lines @@
 
   @override
   InterfaceType get supertype {
     if (isObject) {
       return null;
     }
     return _supertype ??= _computeInterfaceType(_unlinkedClass.supertype);
   }
 
   @override
-  DartType get type =>
+  InterfaceType get type =>
       _type ??= buildType((int i) => typeParameterTypes[i], null);
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedClass.typeParameters;
 
   @override
   ConstructorElementForLink get unnamedConstructor {
     if (!_unnamedConstructorComputed) {
       for (ConstructorElementForLink constructor in constructors) {
@@ skipping 148 matching lines @@
   @override
   List<InterfaceType> get mixins => const [];
 
   @override
   String get name => _unlinkedEnum.name;
 
   @override
   InterfaceType get supertype => library._linker.typeProvider.objectType;
 
   @override
-  DartType get type => _type ??= new InterfaceTypeImpl(this);
+  InterfaceType get type => _type ??= new InterfaceTypeImpl(this);
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   ConstructorElementForLink get unnamedConstructor => null;
 
   /**
    * Get the type of the enum's static member `values`.
    */
@@ skipping 437 matching lines @@
         default:
           // TODO(paulberry): implement other cases as necessary
           throw new UnimplementedError('${element._unlinkedExecutable.kind}');
       }
       return addRawReference(element.name,
           numTypeParameters: element.typeParameters.length,
           containingReference:
               enclosingClass != null ? addReference(enclosingClass) : null,
           dependency: enclosingClass != null
               ? null
-              : library.addDependency(element.library),
+              : library.addDependency(element.library as LibraryElementForLink),
           kind: kind);
     } else if (element is FunctionElementForLink_Initializer) {
       return addRawReference('',
           containingReference: addReference(element.enclosingElement),
           kind: ReferenceKind.function);
     } else if (element is TopLevelVariableElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           kind: ReferenceKind.topLevelPropertyAccessor);
     } else if (element is FieldElementForLink_ClassField) {
@@ skipping 410 matching lines @@
         _unlinkedExecutable != null &&
         _unlinkedExecutable.constCycleSlot != 0) {
       _constNode = new ConstConstructorNode(this);
     }
   }
 
   @override
   ConstructorElementForLink get asConstructor => this;
 
   @override
+  ClassElementImpl get enclosingElement => super.enclosingClass;
+
+  @override
   bool get isCycleFree {
     if (!_constNode.isEvaluated) {
       new ConstDependencyWalker().walk(_constNode);
     }
     return _constNode.isCycleFree;
   }
 
   /**
    * Perform const cycle detection on this constructor.
    */
@@ skipping 203 matching lines @@
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   String _name;
   String _displayName;
 
-  @override
   final CompilationUnitElementForLink compilationUnit;
 
   ExecutableElementForLink(this.compilationUnit, this._unlinkedExecutable);
 
   @override
   ContextForLink get context => compilationUnit.context;
 
   /**
    * If the executable element had an explicitly declared return type, return
    * it.  Otherwise return `null`.
@@ skipping 56 matching lines @@
     return _inferredReturnType;
   }
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
   @override
-  LibraryElementForLink get library => enclosingElement.library;
+  LibraryElement get library => enclosingElement.library;
 
   @override
   String get name {
     if (_name == null) {
       _name = _unlinkedExecutable.name;
       if (_name == '-' && _unlinkedExecutable.parameters.isEmpty) {
         _name = 'unary-';
       }
     }
     return _name;
@@ skipping 25 matching lines @@
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   /**
    * Compute the default return type for this type of executable element (if no
    * return type is declared and strong mode type inference cannot infer a
    * better return type).
    */
   DartType _computeDefaultReturnType() {
     if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
-        library._linker.strongMode) {
+        (library as LibraryElementForLink)._linker.strongMode) {
       // In strong mode, setters without an explicit return type are
       // considered to return `void`.
       return VoidTypeImpl.instance;
     } else {
       return DynamicTypeImpl.instance;
     }
   }
 }
 
 /**
@@ skipping 1732 matching lines @@
     implements MethodElementImpl {
   MethodElementForLink(ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable)
       : super(enclosingClass.enclosingElement, enclosingClass,
             unlinkedExecutable);
 
   @override
   DartType get asStaticType => type;
 
   @override
+  ClassElementImpl get enclosingElement => super.enclosingClass;
+
+  @override
   String get identifier => name;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     // TODO(paulberry): implement.
     return null;
   }
@@ skipping 250 matching lines @@
   DartType get type => enclosingElement.computeVariableType();
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Mixin used by elements that can have parameters.
  */
 abstract class ParameterParentElementForLink implements Element {
-  List<ParameterElementForLink> _parameters;
+  List<ParameterElement> _parameters;
 
   /**
    * Get the appropriate integer list to store in
    * [EntityRef.implicitFunctionTypeIndices] to refer to this element.  For an
    * element representing a function-typed parameter, this should return a
    * non-empty list.  For an element representing an executable, this should
    * return the empty list.
    */
   List<int> get implicitFunctionTypeIndices;
 
   /**
    * Get all the parameters of this element.
    */
-  List<ParameterElementForLink> get parameters {
+  List<ParameterElement> get parameters {
     if (_parameters == null) {
       List<UnlinkedParam> unlinkedParameters = this.unlinkedParameters;
       int numParameters = unlinkedParameters.length;
-      _parameters = new List<ParameterElementForLink>(numParameters);
+      _parameters = new List<ParameterElement>(numParameters);
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = unlinkedParameters[i];
         _parameters[i] = new ParameterElementForLink(
             this,
             unlinkedParam,
             typeParameterContext,
             typeParameterContext.enclosingUnit.resynthesizerContext
             as CompilationUnitElementForLink,
             i);
       }
@@ skipping 105 matching lines @@
 
 /**
  * Specialization of [PropertyAccessorElementForLink] for non-synthetic
  * accessors explicitly declared in the source code.
  */
 class PropertyAccessorElementForLink_Executable
     extends ExecutableElementForLink_NonLocal
     with ReferenceableElementForLink
     implements PropertyAccessorElementForLink {
   @override
-  SyntheticVariableElementForLink variable;
+  PropertyInducingElement variable;
 
   PropertyAccessorElementForLink_Executable(
       CompilationUnitElementForLink enclosingUnit,
       ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable,
       this.variable)
       : super(enclosingUnit, enclosingClass, unlinkedExecutable);
 
   @override
   DartType get asStaticType => returnType;
@@ skipping 12 matching lines @@
 
   @override
   bool get isStatic => enclosingClass == null || super.isStatic;
 
   @override
   ElementKind get kind => _unlinkedExecutable.kind ==
       UnlinkedExecutableKind.getter ? ElementKind.GETTER : ElementKind.SETTER;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
-    return new NonstaticMemberElementForLink(library, this, name);
+    return new NonstaticMemberElementForLink(
+        library as LibraryElementForLink, this, name);
   }
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     // TODO(paulberry): implement
     return null;
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 767 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }