Record dependency information to implement first version of dependency

dart/sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1508 matching lines @@
         methodName = name.slowToString();
       } else if (!node.isInterceptorCall) {
         if (target == backend.jsArrayAdd) {
           methodName = 'push';
         } else if (target == backend.jsArrayRemoveLast) {
           methodName = 'pop';
         } else if (target == backend.jsStringSplit) {
           methodName = 'split';
           // Split returns a List, so we make sure the backend knows the
           // list class is instantiated.
-          world.registerInstantiatedClass(compiler.listClass);
+          world.registerInstantiatedClass(
+              compiler.listClass, compiler.globalDependencies);
         } else if (target == backend.jsStringConcat) {
           push(new js.Binary('+', object, arguments[0]), node);
           return;
         } else if (target.isNative()
                    && !compiler.enableTypeAssertions
                    && target.isFunction()) {
           // Enable direct calls to a native method only if we don't
           // run in checked mode, where the Dart version may have
           // type annotations on parameters and return type that it
           // should check.
@@ skipping 100 matching lines @@
     HType valueType = node.isInterceptorCall
         ? node.inputs[2].instructionType
         : node.inputs[1].instructionType;
     backend.addedDynamicSetter(selector, valueType);
     registerInvoke(node, selector);
   }
 
   void registerGetter(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
     world.registerDynamicGetter(selector.name, selector);
-    world.registerInstantiatedClass(compiler.functionClass);
+    world.registerInstantiatedClass(
+        compiler.functionClass, compiler.globalDependencies);
     registerInvoke(node, selector);
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     String name = backend.namer.invocationName(node.selector);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     registerSetter(node);
   }
 
@@ skipping 107 matching lines @@
     use(node.value);
     assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   void registerForeignType(HType type) {
     DartType dartType = type.computeType(compiler);
     if (dartType == null) {
       assert(type == HType.UNKNOWN);
       return;
     }
-    world.registerInstantiatedClass(dartType.element);
+    world.registerInstantiatedClass(
+        dartType.element, compiler.globalDependencies);
   }
 
   visitForeign(HForeign node) {
     String code = node.code.slowToString();
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement()) {
       if (!inputs.isEmpty) {
         compiler.internalError("foreign statement with inputs: $code",
                                instruction: node);
       }
@@ skipping 43 matching lines @@
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
     DartType type = node.constant.computeType(compiler);
     if (node.constant is ConstructedConstant) {
       ConstantHandler handler = compiler.constantHandler;
       handler.registerCompileTimeConstant(node.constant);
     }
-    world.registerInstantiatedClass(type.element);
+    world.registerInstantiatedClass(
+        type.element, compiler.globalDependencies);
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
     attachLocationToLast(node);
   }
 
   static String mapRelationalOperator(String op, bool inverse) {
     Map<String, String> inverseOperator = const <String, String>{
@@ skipping 188 matching lines @@
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     // Check whether this static is used for anything else than as a target in
     // a static call.
     node.usedBy.forEach((HInstruction instr) {
       if (instr is !HInvokeStatic) {
         backend.registerNonCallStaticUse(node);
         if (node.element.isFunction()) {
-          world.registerInstantiatedClass(compiler.functionClass);
+          world.registerInstantiatedClass(
+              compiler.functionClass, compiler.globalDependencies);
         }
       } else if (instr.target != node) {
         backend.registerNonCallStaticUse(node);
       }
     });
     Element element = node.element;
     world.registerStaticUse(element);
     ClassElement cls = element.getEnclosingClass();
     if (element.isGenerativeConstructor()
         || (element.isFactoryConstructor() && cls == compiler.listClass)) {
-      world.registerInstantiatedClass(cls);
+      world.registerInstantiatedClass(cls, compiler.globalDependencies);
     }
     push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
     String lazyGetter = backend.namer.isolateLazyInitializerAccess(element);
     js.VariableUse target = new js.VariableUse(lazyGetter);
     js.Call call = new js.Call(target, <js.Expression>[]);
@@ skipping 35 matching lines @@
       Element convertToString = backend.getStringInterpolationHelper();
       world.registerStaticUse(convertToString);
       js.VariableUse variableUse =
           new js.VariableUse(backend.namer.isolateAccess(convertToString));
       use(node);
       push(new js.Call(variableUse, <js.Expression>[pop()]), node);
     }
   }
 
   void visitLiteralList(HLiteralList node) {
-    world.registerInstantiatedClass(compiler.listClass);
+    world.registerInstantiatedClass(
+        compiler.listClass, compiler.globalDependencies);
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     int len = node.inputs.length;
     List<js.ArrayElement> elements = <js.ArrayElement>[];
     for (int i = 0; i < len; i++) {
       use(node.inputs[i]);
       elements.add(new js.ArrayElement(i, pop()));
     }
@@ skipping 113 matching lines @@
     js.Expression objectTest = pop();
     checkType(input, type);
     push(new js.Binary('||',
                        functionTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
     assert(invariant(input, !type.isMalformed,
                      message: 'Attempt to check malformed type $type'));
-    world.registerIsCheck(type);
+    world.registerIsCheck(type, compiler.globalDependencies);
     Element element = type.element;
     use(input);
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), backend.namer.operatorIs(element));
     if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
       push(new js.Prefix('!', field));
@@ skipping 41 matching lines @@
     checkArray(input, '===');
     js.Expression arrayTest = pop();
     checkType(input, type);
     push(new js.Binary('&&',
                        objectTest,
                        new js.Binary('||', arrayTest, pop())));
   }
 
   void visitIs(HIs node) {
     DartType type = node.typeExpression;
-    world.registerIsCheck(type);
+    world.registerIsCheck(type, compiler.globalDependencies);
     Element element = type.element;
     if (identical(element.kind, ElementKind.TYPE_VARIABLE)) {
       compiler.unimplemented("visitIs for type variables",
                              instruction: node.expression);
     }
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
     if (identical(element, objectClass) ||
@@ skipping 52 matching lines @@
     if (node.nullOk) {
       checkNull(input);
       push(new js.Binary('||', pop(), pop()), node);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isChecked) {
       DartType type = node.instructionType.computeType(compiler);
       Element element = type.element;
-      world.registerIsCheck(type);
+      world.registerIsCheck(type, compiler.globalDependencies);
 
       if (node.isArgumentTypeCheck) {
         if (element == backend.jsIntClass) {
           checkInt(node.checkedInput, '!==');
         } else {
           assert(element == backend.jsNumberClass);
           checkNum(node.checkedInput, '!==');
         }
         js.Expression test = pop();
         js.Block oldContainer = currentContainer;
@@ skipping 564 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }