Use WorldImpact for element dependencies in deferred_load

pkg/compiler/lib/src/resolution/constructors.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 dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
@@ skipping 105 matching lines @@
       } else if (!target.isInstanceMember) {
         reporter.reportErrorMessage(
             selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       } else {
         field = target;
       }
     } else {
       reporter.reportErrorMessage(
           init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
-    registry.useElement(init, target);
-    registry.registerStaticUse(target);
-    checkForDuplicateInitializers(target, init);
+    if (target != null) {
+      registry.useElement(init, target);
+      registry.registerStaticUse(target);
+      checkForDuplicateInitializers(target, init);
+    }
     // Resolve initializing value.
     ResolutionResult result = visitor.visitInStaticContext(
         init.arguments.head,
         inConstantInitializer: isConst);
     if (isConst) {
       if (result.isConstant && field != null) {
         // TODO(johnniwinther): Report error if `result.constant` is `null`.
         fieldInitializers[field] = result.constant;
       } else {
         isValidAsConstant = false;
@@ skipping 33 matching lines @@
         constructor.library, lookupTarget, constructorSelector.name);
 
     final bool isImplicitSuperCall = false;
     final String className = lookupTarget.name;
     verifyThatConstructorMatchesCall(calledConstructor,
                                      argumentsResult.callStructure,
                                      isImplicitSuperCall,
                                      call,
                                      className,
                                      constructorSelector);
-
-    registry.useElement(call, calledConstructor);
-    registry.registerStaticUse(calledConstructor);
+    if (calledConstructor != null) {
+      registry.useElement(call, calledConstructor);
+      registry.registerStaticUse(calledConstructor);
+    }
     if (isConst) {
       if (isValidAsConstant &&
           calledConstructor.isConst &&
           argumentsResult.isValidAsConstant) {
         CallStructure callStructure = argumentsResult.callStructure;
         List<ConstantExpression> arguments = argumentsResult.constantArguments;
         return new ConstantResult(
             call,
             new ConstructedConstantExpression(
                 targetType,
@@ skipping 26 matching lines @@
           constructorSelector.name);
 
       final String className = lookupTarget.name;
       final bool isImplicitSuperCall = true;
       verifyThatConstructorMatchesCall(calledConstructor,
                                        CallStructure.NO_ARGS,
                                        isImplicitSuperCall,
                                        functionNode,
                                        className,
                                        constructorSelector);
-      registry.registerImplicitSuperCall(calledConstructor);
-      registry.registerStaticUse(calledConstructor);
+      if (calledConstructor != null) {
+        registry.registerImplicitSuperCall(calledConstructor);
+        registry.registerStaticUse(calledConstructor);
+      }
 
       if (isConst && isValidAsConstant) {
         return new ConstructedConstantExpression(
             targetType,
             calledConstructor,
             CallStructure.NO_ARGS,
             const <ConstantExpression>[]);
       }
     }
     return null;
@@ skipping 507 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }