dart2js: mark FunctionElements as dependencies always

pkg/compiler/lib/src/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 'common.dart';
 import 'common/backend_api.dart' show
     Backend;
 import 'common/tasks.dart' show
@@ skipping 323 matching lines @@
 
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       ConstantValue constant =
           backend.constants.getConstantValueForMetadata(metadata);
       if (constant != null) {
         constants.add(constant);
       }
     }
 
-    if (element is FunctionElement &&
-        compiler.resolverWorld.closurizedMembers.contains(element)) {

[Siggi Cherem (dart-lang), 2015/10/12 22:53:28]

mmm - would this pull in more than needed? Seems like in your test case though,
we were including B, but we were missing A, right? In that case, could it be
that the function dependency (foo -> B) is correct, but we are missing is the
dependency from a type to its super class (B -> A)?

[Harry Terkelsen, 2015/10/13 17:27:34]

The class to superclass dependency is handled here:
https://github.com/dart-lang/sdk/blob/master/pkg/compiler/lib/src/deferred_lo...

[Siggi Cherem (dart-lang), 2015/10/13 20:16:29]

Thanks for the pointer. Sorry for the confusion - I was seeing something
strange, the out.js file before your fix included foo and B's declaration, but
it appears that B was added later and not here, which would explain that we
weren't treating B as an actual dependency and adding A as well.

+    if (element is FunctionElement) {
       collectTypeDependencies(element.type);
     }
 
     if (element.isClass) {
       // If we see a class, add everything its live instance members refer
       // to.  Static members are not relevant, unless we are processing
       // extra dependencies due to mirrors.
       void addLiveInstanceMember(Element element) {
         if (!compiler.enqueuer.resolution.hasBeenProcessed(element)) return;
         if (!isMirrorUsage && !element.isInstanceMember) return;
@@ skipping 579 matching lines @@
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }