Use Object as supertype in face of invalid supertypes.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 3643 matching lines @@
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
 
   TypeDefinitionVisitor(Compiler compiler,
                         TypeDeclarationElement element,
                         TreeElementMapping mapping)
       : this.enclosingElement = element,
         scope = Scope.buildEnclosingScope(element),
         super(compiler, mapping);
 
+  DartType get objectType => compiler.objectClass.rawType;
+
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     var nameSet = new Setlet<String>();
     // Resolve the bounds of type variables.
     Link<DartType> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       TypeVariableType typeVariable = typeLink.head;
       String typeName = typeVariable.name;
@@ skipping 25 matching lines @@
                     {'typeVariableName': variableElement.name});
               }
               break;
             }
             seenTypeVariables = seenTypeVariables.prepend(element);
             bound = element.bound;
           }
         }
         addDeferredAction(element, checkTypeVariableBound);
       } else {
-        variableElement.bound = compiler.objectClass.computeType(compiler);
+        variableElement.bound = objectType;
       }
       nodeLink = nodeLink.tail;
       typeLink = typeLink.tail;
     }
     assert(typeLink.isEmpty);
   }
 }
 
 class TypedefResolverVisitor extends TypeDefinitionVisitor {
   TypedefElement get element => enclosingElement;
@@ skipping 393 matching lines @@
 
   DartType resolveType(TypeAnnotation node) {
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_MALFORMED);
-        return null;
+        return objectType;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         compiler.reportError(superclass.typeName,
             MessageKind.CLASS_NAME_EXPECTED);
-        return null;
+        return objectType;
       } else if (isBlackListed(supertype)) {
         compiler.reportError(superclass, MessageKind.CANNOT_EXTEND,
             {'type': supertype});
-        return null;
+        return objectType;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = resolveType(link.head);
@@ skipping 420 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }