Revert "Deferred loading: handle type arguments of superclasses."

sdk/lib/_internal/compiler/implementation/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 28 matching lines @@
     LiteralDartString;
 
 import 'resolution/resolution.dart' show
     TreeElements;
 
 import 'mirrors_used.dart' show
     MirrorUsageAnalyzer,
     MirrorUsageAnalyzerTask,
     MirrorUsage;
 
-import "dart_types.dart" show
-   DartType,
-   VoidType,
-   InterfaceType,
-   FunctionType,
-   TypeVariableType,
-   MalformedType,
-   TypedefType;
-
 /// A "hunk" of the program that will be loaded whenever one of its [imports]
 /// are loaded.
 ///
 /// Elements that are only used in one deferred import, is in an OutputUnit with
 /// the deferred import as single element in the [imports] set.
 ///
 /// Whenever a deferred Element is shared between several deferred imports it is
 /// in an output unit with those imports in the [imports] Set.
 ///
 /// OutputUnits are equal if their [imports] are equal.
@@ skipping 66 matching lines @@
   /// [LibraryElement] they import.
   /// The main library is included in this set for convenience.
   final Map<Import, LibraryElement> _allDeferredImports =
       new Map<Import, LibraryElement>();
 
   // For each deferred import we want to know exactly what elements have to
   // be loaded.
   Map<Import, Set<Element>> _importedDeferredBy = null;
   Map<Import, Set<Constant>> _constantsDeferredBy = null;
 
-  // The types we have visited in [addNestedTypes].
-  Set<DartType> _visitedTypes;
-
   Set<Element> _mainElements = new Set<Element>();
 
   DeferredLoadTask(Compiler compiler) : super(compiler);
 
   /// Returns the [OutputUnit] where [element] belongs.
   OutputUnit outputUnitForElement(Element element) {
     if (!splitProgram) return mainOutputUnit;
 
     element = element.implementation;
     while (!_elementToOutputUnit.containsKey(element)) {
@@ skipping 136 matching lines @@
         if (!e.isInstanceMember()) return;
         _collectDependencies(e.implementation, elements, constants);
       });
       if (cls.implementation != cls) {
         // TODO(ahe): Why doesn't ClassElement.forEachLocalMember do this?
         cls.implementation.forEachLocalMember((Element e) {
           if (!e.isInstanceMember()) return;
           _collectDependencies(e.implementation, elements, constants);
         });
       }
-      // Adds, recursively, to [elements] any types the [type] depends on in its
-      // type arguments.
-      void addNestedTypes(DartType type) {
-        if (_visitedTypes.contains(type)) return;
-        _visitedTypes.add(type);
-        // Gives a FunctionType from a TypedefType.
-        type = type.unalias(compiler);
-        // Only add concrete types.
-        if (type is VoidType) return;
-        if (type is TypeVariableType) return;
-        if (type is MalformedType) return;
-        if (type is FunctionType) {
-          FunctionType functionType = type;
-          addNestedTypes(functionType.returnType);
-          for (DartType parameterType in functionType.parameterTypes) {
-            addNestedTypes(parameterType);
-          }
-          for (DartType parameterType in functionType.optionalParameterTypes) {
-            addNestedTypes(parameterType);
-          }
-          for (DartType parameterType in functionType.namedParameterTypes) {
-            addNestedTypes(parameterType);
-          }
-          return;
-        }
-        assert(invariant(type.element, type is InterfaceType,
-                         message: "Unrecognized type: $type"));
-        InterfaceType interfaceType = type;
-        for (DartType typeArgument in interfaceType.typeArguments) {
-          addNestedTypes(typeArgument);
-        }
+      for (var type in cls.implementation.allSupertypes) {
         elements.add(type.element.implementation);
       }
-      for (DartType supertype in cls.implementation.allSupertypes) {
-        addNestedTypes(supertype);
-      }
       elements.add(cls.implementation);
     } else if (Elements.isStaticOrTopLevel(element) ||
                element.isConstructor()) {
       _collectDependencies(element, elements, constants);
     }
     if (element.isGenerativeConstructor()) {
       // When instantiating a class, we record a reference to the
       // constructor, not the class itself.  We must add all the
       // instance members of the constructor's class.
       ClassElement implementation =
@@ skipping 246 matching lines @@
   void onResolutionComplete(FunctionElement main) {
     if (!splitProgram) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
     LibraryElement mainLibrary = main.getLibrary();
     _importedDeferredBy = new Map<Import, Set<Element>>();
     _constantsDeferredBy = new Map<Import, Set<Constant>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
-    _visitedTypes = new Set<DartType>();
 
     measureElement(mainLibrary, () {
 
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(compiler.mainFunction, _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
       // things that the backend need but cannot associate with a particular
       // element, for example, startRootIsolate.  This set also contains
       // elements for which we lack precise information.
@@ skipping 15 matching lines @@
         }
         for (Constant constant in _constantsDeferredBy[import]) {
           allConstants.add(constant);
           _addImportToOutputUnitOfConstant(constant, import);
         }
       }
 
       // Release maps;
       _importedDeferredBy = null;
       _constantsDeferredBy = null;
-      _visitedTypes = null;
 
       _adjustConstantsOutputUnit(allConstants);
 
       // Find all the output units we have used.
       // Also generate a unique name for each OutputUnit.
       for (OutputUnit outputUnit in _elementToOutputUnit.values) {
         allOutputUnits.add(outputUnit);
       }
       for (OutputUnit outputUnit in _constantToOutputUnit.values) {
         allOutputUnits.add(outputUnit);
@@ skipping 24 matching lines @@
       }
     }
     if (splitProgram && !deferredUsedFromMain) {
       compiler.reportInfo(
           lastDeferred,
           MessageKind.DEFERRED_LIBRARY_NOT_FROM_MAIN);
       splitProgram = false;
     }
   }
 }