More strong mode changes to analysis_server

pkg/analysis_server/lib/src/status/validator.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.
 
 library analysis_server.src.status.validator;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 46 matching lines @@
    */
   bool get hasDifference => _buffer.length > 0;
 
   /**
    * Compare the [expected] and [actual] elements. The results of the comparison
    * can be accessed via the [hasDifference] and [description] getters.
    */
   void compareElements(Element expected, Element actual) {
     if (expected == null) {
       if (actual != null) {
-        _writeMismatch(expected, actual, (Element element) {
+        _writeMismatch(expected, actual, (Object element) {
           return element == null ? 'null' : 'non null ${element.runtimeType}';
         });
       }
     } else if (actual == null) {
-      _writeMismatch(expected, actual, (Element element) {
+      _writeMismatch(expected, actual, (Object element) {
         return element == null ? 'null' : 'non null ${element.runtimeType}';
       });
     } else if (expected is ClassElement && actual is ClassElement) {
       _compareClassElements(expected, actual);
     } else if (expected is CompilationUnitElement &&
         actual is CompilationUnitElement) {
       _compareCompilationUnitElements(expected, actual);
     } else if (expected is ConstructorElement && actual is ConstructorElement) {
       _compareConstructorElements(expected, actual);
     } else if (expected is ExportElement && actual is ExportElement) {
@@ skipping 45 matching lines @@
 
   void _compareClassElements(ClassElement expected, ClassElement actual) {
     _compareGenericElements(expected, actual);
     //
     // Compare attributes.
     //
     if (expected.hasReferenceToSuper != actual.hasReferenceToSuper) {
       _writeMismatch(
           expected,
           actual,
-          (ClassElement element) => element.hasReferenceToSuper
+          (Object element) => (element as ClassElement).hasReferenceToSuper
               ? 'a class that references super'
               : 'a class that does not reference super');
     }
     if (expected.isAbstract != actual.isAbstract) {
       _writeMismatch(
           expected,
           actual,
-          (ClassElement element) =>
-              element.isAbstract ? 'an abstract class' : 'a concrete class');
+          (Object element) => (element as ClassElement).isAbstract
+              ? 'an abstract class'
+              : 'a concrete class');
     }
     if (expected.isEnum != actual.isEnum ||
         expected.isMixinApplication != actual.isMixinApplication) {
-      _writeMismatch(
-          expected,
-          actual,
-          (ClassElement element) => element.isEnum
-              ? 'an enum'
-              : (element.isMixinApplication
-                  ? 'a mixin application'
-                  : 'a class'));
+      _writeMismatch(expected, actual, (Object element) {
+        ClassElement classElement = element as ClassElement;
+        return classElement.isEnum
+            ? 'an enum'
+            : (classElement.isMixinApplication
+                ? 'a mixin application'
+                : 'a class');
+      });
     }
     if (expected.isOrInheritsProxy != actual.isOrInheritsProxy) {
       _writeMismatch(
           expected,
           actual,
-          (ClassElement element) => element.isOrInheritsProxy
+          (Object element) => (element as ClassElement).isOrInheritsProxy
               ? 'a class that is marked as a proxy'
               : 'a class that is not marked as a proxy');
     }
     if (expected.isValidMixin != actual.isValidMixin) {
       _writeMismatch(
           expected,
           actual,
-          (ClassElement element) =>
-              element.isValidMixin ? 'a valid mixin' : 'an invalid mixin');
+          (Object element) => (element as ClassElement).isValidMixin
+              ? 'a valid mixin'
+              : 'an invalid mixin');
     }
     _compareTypes('supertype', expected.supertype, actual.supertype);
     _compareTypeLists('mixin', expected.mixins, actual.mixins);
     _compareTypeLists('interface', expected.interfaces, actual.interfaces);
     //
     // Compare children.
     //
     _compareElementLists(expected.accessors, actual.accessors);
     _compareElementLists(expected.constructors, actual.constructors);
     _compareElementLists(expected.fields, actual.fields);
@@ skipping 19 matching lines @@
   void _compareConstructorElements(
       ConstructorElement expected, ConstructorElement actual) {
     _compareExecutableElements(expected, actual, 'constructor');
     //
     // Compare attributes.
     //
     if (expected.isConst != actual.isConst) {
       _writeMismatch(
           expected,
           actual,
-          (ConstructorElement element) => element.isConst
+          (Object element) => (element as ConstructorElement).isConst
               ? 'a const constructor'
               : 'a non-const constructor');
     }
     if (expected.isFactory != actual.isFactory) {
       _writeMismatch(
           expected,
           actual,
-          (ConstructorElement element) => element.isFactory
+          (Object element) => (element as ConstructorElement).isFactory
               ? 'a factory constructor'
               : 'a non-factory constructor');
     }
     if (expected.periodOffset != actual.periodOffset) {
       _write('Expected a period offset of ');
       _write(expected.periodOffset);
       _write('; found ');
       _writeln(actual.periodOffset);
     }
     if ((expected.redirectedConstructor == null) !=
         (actual.redirectedConstructor == null)) {
       _writeMismatch(
           expected,
           actual,
-          (ConstructorElement element) => element.redirectedConstructor == null
-              ? 'a redirecting constructor'
-              : 'a non-redirecting constructor');
+          (Object element) =>
+              (element as ConstructorElement).redirectedConstructor == null
+                  ? 'a redirecting constructor'
+                  : 'a non-redirecting constructor');
     }
   }
 
   void _compareElementLists(List expected, List actual) {
     Set<Element> extraElements = new HashSet<Element>();
     Map<Element, Element> commonElements = new HashMap<Element, Element>();
 
     Map<String, Element> expectedElements = new HashMap<String, Element>();
     for (Element expectedElement in expected) {
       expectedElements[expectedElement.name] = expectedElement;
@@ skipping 36 matching lines @@
   void _compareExecutableElements(
       ExecutableElement expected, ExecutableElement actual, String kind) {
     _compareGenericElements(expected, actual);
     //
     // Compare attributes.
     //
     if (expected.hasImplicitReturnType != actual.hasImplicitReturnType) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) => element.hasImplicitReturnType
-              ? 'an implicit return type'
-              : 'an explicit return type');
+          (Object element) =>
+              (element as ExecutableElement).hasImplicitReturnType
+                  ? 'an implicit return type'
+                  : 'an explicit return type');
     }
     if (expected.isAbstract != actual.isAbstract) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) =>
-              element.isAbstract ? 'an abstract $kind' : 'a concrete $kind');
+          (Object element) => (element as ExecutableElement).isAbstract
+              ? 'an abstract $kind'
+              : 'a concrete $kind');
     }
     if (expected.isAsynchronous != actual.isAsynchronous) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) => element.isAsynchronous
+          (Object element) => (element as ExecutableElement).isAsynchronous
               ? 'an asynchronous $kind'
               : 'a synchronous $kind');
     }
     if (expected.isExternal != actual.isExternal) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) => element.isExternal
+          (Object element) => (element as ExecutableElement).isExternal
               ? 'an external $kind'
               : 'a non-external $kind');
     }
     if (expected.isGenerator != actual.isGenerator) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) => element.isGenerator
+          (Object element) => (element as ExecutableElement).isGenerator
               ? 'a generator $kind'
               : 'a non-generator $kind');
     }
     if (expected.isOperator != actual.isOperator) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) =>
-              element.isOperator ? 'an operator' : 'a non-operator $kind');
+          (Object element) => (element as ExecutableElement).isOperator
+              ? 'an operator'
+              : 'a non-operator $kind');
     }
     if (expected.isStatic != actual.isStatic) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) =>
-              element.isStatic ? 'a static $kind' : 'an instance $kind');
+          (Object element) => (element as ExecutableElement).isStatic
+              ? 'a static $kind'
+              : 'an instance $kind');
     }
     if ((expected.returnType == null) != (actual.returnType == null)) {
       _writeMismatch(
           expected,
           actual,
-          (ExecutableElement element) => element.returnType == null
+          (Object element) => (element as ExecutableElement).returnType == null
               ? 'a $kind with no return type'
               : 'a $kind with a return type');
     } else {
       _compareTypes('return type', expected.returnType, actual.returnType);
     }
     //
     // Compare children.
     //
     _compareElementLists(expected.functions, actual.functions);
     _compareElementLists(expected.labels, actual.labels);
     _compareElementLists(expected.localVariables, actual.localVariables);
     _compareElementLists(expected.parameters, actual.parameters);
     _compareElementLists(expected.typeParameters, actual.typeParameters);
   }
 
   void _compareExportElements(ExportElement expected, ExportElement actual) {
     _compareUriReferencedElements(expected, actual);
     //
     // Compare attributes.
     //
     if ((expected.exportedLibrary == null) !=
         (actual.exportedLibrary == null)) {
       // TODO(brianwilkerson) Check for more than existence?
-      _writeMismatch(
-          expected,
-          actual,
-          (ExportElement element) => element.exportedLibrary == null
-              ? 'unresolved uri'
-              : 'uri resolved to ${element.exportedLibrary.source.fullName}');
+      _writeMismatch(expected, actual, (Object element) {
+        ExportElement exportElement = element as ExportElement;
+        return exportElement.exportedLibrary == null
+            ? 'unresolved uri'
+            : 'uri resolved to ${exportElement.exportedLibrary.source.fullName}';
+      });
     }
     //
     // Compare children.
     //
     _compareElementLists(expected.combinators, actual.combinators);
   }
 
   void _compareFieldElements(FieldElement expected, FieldElement actual) {
     _comparePropertyInducingElements(expected, actual, 'field');
     //
     // Compare attributes.
     //
     if (expected.isEnumConstant != actual.isEnumConstant) {
       _writeMismatch(
           expected,
           actual,
-          (FieldElement element) =>
-              element.isEnumConstant ? 'an enum constant' : 'a normal field');
+          (Object element) => (element as FieldElement).isEnumConstant
+              ? 'an enum constant'
+              : 'a normal field');
     }
   }
 
   void _compareFieldFormalParameterElements(
       FieldFormalParameterElement expected,
       FieldFormalParameterElement actual) {
     // TODO(brianwilkerson) Implement this
     _compareGenericElements(expected, actual);
   }
 
@@ skipping 30 matching lines @@
 
   void _compareImportElements(ImportElement expected, ImportElement actual) {
     _compareUriReferencedElements(expected, actual);
     //
     // Compare attributes.
     //
     if (expected.isDeferred != actual.isDeferred) {
       _writeMismatch(
           expected,
           actual,
-          (ImportElement element) => element.isDeferred
+          (Object element) => (element as ImportElement).isDeferred
               ? 'a deferred import'
               : 'a non-deferred import');
     }
     if ((expected.importedLibrary == null) !=
         (actual.importedLibrary == null)) {
-      _writeMismatch(
-          expected,
-          actual,
-          (ImportElement element) => element.importedLibrary == null
-              ? 'unresolved uri'
-              : 'uri resolved to ${element.importedLibrary.source.fullName}');
+      _writeMismatch(expected, actual, (Object element) {
+        ImportElement importElement = element as ImportElement;
+        return importElement.importedLibrary == null
+            ? 'unresolved uri'
+            : 'uri resolved to ${importElement.importedLibrary.source.fullName}';
+      });
     }
     if ((expected.prefix == null) != (actual.prefix == null)) {
-      _writeMismatch(
-          expected,
-          actual,
-          (ImportElement element) => element.prefix == null
-              ? 'no prefix'
-              : 'a prefix named ${element.prefix.name}');
+      _writeMismatch(expected, actual, (Object element) {
+        ImportElement importElement = element as ImportElement;
+        return importElement.prefix == null
+            ? 'no prefix'
+            : 'a prefix named ${importElement.prefix.name}';
+      });
     }
     if (expected.prefixOffset != actual.prefixOffset) {
       _write('Expected a prefix offset of ');
       _write(expected.prefixOffset);
       _write('; found ');
       _writeln(actual.prefixOffset);
     }
     //
     // Compare children.
     //
@@ skipping 36 matching lines @@
   void _compareMethodElements(MethodElement expected, MethodElement actual) {
     // TODO(brianwilkerson) Implement this
     _compareExecutableElements(expected, actual, 'method');
     //
     // Compare attributes.
     //
     if (expected.isStatic != actual.isStatic) {
       _writeMismatch(
           expected,
           actual,
-          (FieldElement element) =>
-              element.isStatic ? 'a static field' : 'an instance field');
+          (Object element) => (element as FieldElement).isStatic
+              ? 'a static field'
+              : 'an instance field');
     }
   }
 
   void _compareMultiplyDefinedElements(
       MultiplyDefinedElement expected, MultiplyDefinedElement actual) {
     // TODO(brianwilkerson) Implement this
   }
 
   void _compareParameterElements(
       ParameterElement expected, ParameterElement actual) {
@@ skipping 142 matching lines @@
       VariableElement expected, VariableElement actual, String kind) {
     _compareGenericElements(expected, actual);
     //
     // Compare attributes.
     //
     if ((expected.constantValue == null) != (actual.constantValue == null)) {
       // TODO(brianwilkerson) Check for more than existence.
       _writeMismatch(
           expected,
           actual,
-          (VariableElement element) => element.constantValue == null
+          (Object element) => (element as VariableElement).constantValue == null
               ? 'a $kind with no constant value'
               : 'a $kind with a constant value');
     }
     if (expected.hasImplicitType != actual.hasImplicitType) {
       _writeMismatch(
           expected,
           actual,
-          (VariableElement element) => element.hasImplicitType
+          (Object element) => (element as VariableElement).hasImplicitType
               ? 'a $kind with an implicit type'
               : 'a $kind with an explicit type');
     }
     if (expected.isConst != actual.isConst) {
       _writeMismatch(
           expected,
           actual,
-          (VariableElement element) =>
-              element.isConst ? 'a const $kind' : 'a non-const $kind');
+          (Object element) => (element as VariableElement).isConst
+              ? 'a const $kind'
+              : 'a non-const $kind');
     }
     if (expected.isFinal != actual.isFinal) {
       _writeMismatch(
           expected,
           actual,
-          (VariableElement element) =>
-              element.isFinal ? 'a final $kind' : 'a non-final $kind');
+          (Object element) => (element as VariableElement).isFinal
+              ? 'a final $kind'
+              : 'a non-final $kind');
     }
     if (expected.isStatic != actual.isStatic) {
       _writeMismatch(
           expected,
           actual,
-          (VariableElement element) =>
-              element.isStatic ? 'a static $kind' : 'an instance $kind');
+          (Object element) => (element as VariableElement).isStatic
+              ? 'a static $kind'
+              : 'an instance $kind');
     }
     //
     // Compare children.
     //
     compareElements(expected.initializer, actual.initializer);
   }
 
   void _write(Object value) {
     if (_needsLineBreak) {
       _buffer.write('</p><p>');
@@ skipping 1033 matching lines @@
    * Determine whether or not there is any interesting difference between the
    * original and cloned values.
    */
   void _performComparison() {
     StringBuffer buffer = new StringBuffer();
     if (!_compareObjects(cloneValue, originalValue, buffer)) {
       description = buffer.toString();
     }
   }
 }