Fix NPE when analyzing Object

pkg/analyzer/lib/src/task/dart.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 analyzer.src.task.dart;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 316 matching lines @@
 
   @override
   void internalPerform() {
     List<AnalysisError> errors = <AnalysisError>[];
     //
     // Prepare inputs.
     //
     ClassElementImpl classElement = this.target;
     List<ConstructorElement> superConstructors = inputs[SUPER_CONSTRUCTORS];
     DartType superType = classElement.supertype;
-    ClassElement superElement = superType.element;
     //
     // Shortcut for ClassElement(s) without implicit constructors.
     //
     if (superConstructors == null) {
       outputs[CONSTRUCTORS] = classElement.constructors;
       outputs[CONSTRUCTORS_ERRORS] = AnalysisError.NO_ERRORS;
       return;
     }
     //
     // ClassTypeAlias
     //
     if (classElement.isTypedef) {
       List<ConstructorElement> implicitConstructors =
           new List<ConstructorElement>();
       void callback(ConstructorElement explicitConstructor,
           List<DartType> parameterTypes, List<DartType> argumentTypes) {
         implicitConstructors.add(_createImplicitContructor(classElement.type,
             explicitConstructor, parameterTypes, argumentTypes));
       }
       if (_findForwardedConstructors(classElement, superType, callback)) {
         if (implicitConstructors.isEmpty) {
           errors.add(new AnalysisError.con2(classElement.source,
               classElement.nameOffset, classElement.name.length,
               CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-              [superElement.name]));
+              [superType.element.name]));
         } else {
           classElement.constructors = implicitConstructors;
         }
       }
       outputs[CONSTRUCTORS] = classElement.constructors;
       outputs[CONSTRUCTORS_ERRORS] = errors;
     }
     //
     // ClassDeclaration
     //
     if (!classElement.isTypedef) {
       bool constructorFound = false;
       void callback(ConstructorElement explicitConstructor,
           List<DartType> parameterTypes, List<DartType> argumentTypes) {
         constructorFound = true;
       }
       if (_findForwardedConstructors(classElement, superType, callback) &&
           !constructorFound) {
         SourceRange withRange = classElement.withClauseRange;
         errors.add(new AnalysisError.con2(classElement.source, withRange.offset,
             withRange.length, CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-            [superElement.name]));
+            [superType.element.name]));
         classElement.mixinErrorsReported = true;
       }
       outputs[CONSTRUCTORS] = classElement.constructors;
       outputs[CONSTRUCTORS_ERRORS] = errors;
     }
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
@@ skipping 67 matching lines @@
     type.typeArguments = classType.typeArguments;
     implicitConstructor.type = type;
     return implicitConstructor;
   }
 
   /**
    * Find all the constructors that should be forwarded from the given
    * [superType], to the class or mixin application [classElement],
    * and pass information about them to [callback].
    *
-   * Return true if some constructors were considered.  (A false return value
+   * Return `true` if some constructors were considered. (A `false` return value
    * can only happen if the supeclass is a built-in type, in which case it
    * can't be used as a mixin anyway).
    */
   static bool _findForwardedConstructors(ClassElementImpl classElement,
       InterfaceType superType, void callback(
           ConstructorElement explicitConstructor, List<DartType> parameterTypes,
           List<DartType> argumentTypes)) {
+    if (superType == null) {
+      return false;
+    }
     ClassElement superclassElement = superType.element;
     List<ConstructorElement> constructors = superclassElement.constructors;
     int count = constructors.length;
     if (count == 0) {
       return false;
     }
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(superType.typeParameters);
     List<DartType> argumentTypes = _getArgumentTypes(superType, parameterTypes);
     for (int i = 0; i < count; i++) {
@@ skipping 2112 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }