Emit program and dependency information as relations in a Prolog database.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 264 matching lines @@
   static const checkedModeHelpers = CheckedModeHelper.helpers;
 
   // Checked mode helpers indexed by name.
   Map<String, CheckedModeHelper> checkedModeHelperByName =
       new Map<String, CheckedModeHelper>.fromIterable(
           checkedModeHelpers,
           key: (helper) => helper.name);
 
   TypeVariableHandler typeVariableHandler;
 
+  static const bool DUMP_DEPENDENCIES =
+      const bool.fromEnvironment('DUMP_DEPENDENCIES');
+
   /// Number of methods compiled before considering reflection.
   int preMirrorsMethodCount = 0;
 
   /// Resolution and codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsAnalysis customElementsAnalysis;
 
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
@@ skipping 562 matching lines @@
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e =
           compiler.findHelper('boolConversionCheck');
       if (e != null) enqueue(world, e, registry);
     }
     registerCheckedModeHelpers(registry);
   }
 
-  onResolutionComplete() => rti.computeClassesNeedingRti();
+  onResolutionComplete() {
+    super.onResolutionComplete();
+    rti.computeClassesNeedingRti();
+  }
 
   void onStringInterpolation(Registry registry) {
     assert(registry.isForResolution);
     registerBackendStaticInvocation(getStringInterpolationHelper(), registry);
   }
 
   void onCatchStatement(Registry registry) {
     assert(registry.isForResolution);
     registerBackendStaticInvocation(getExceptionUnwrapper(), registry);
     registerBackendInstantiation(jsPlainJavaScriptObjectClass, registry);
@@ skipping 206 matching lines @@
     assert(registry.isForResolution);
     registerBackendStaticInvocation(getFallThroughError(), registry);
   }
 
   void registerCheckDeferredIsLoaded(Registry registry) {
     enqueueInResolution(getCheckDeferredIsLoaded(), registry);
     // Also register the types of the arguments passed to this method.
     enqueueClass(compiler.enqueuer.resolution, compiler.stringClass, registry);
   }
 
-  void enableNoSuchMethod(Enqueuer world) {
+  void enableNoSuchMethod(context, Enqueuer world) {
     enqueue(world, getCreateInvocationMirror(), compiler.globalDependencies);
-    world.registerInvocation(compiler.noSuchMethodSelector);
+    world.registerInvocation(context, compiler.noSuchMethodSelector);
   }
 
   void onSuperNoSuchMethod(Registry registry) {
     assert(registry.isForResolution);
     registerBackendStaticInvocation(getCreateInvocationMirror(), registry);
     registerBackendStaticInvocation(
         compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD),
         registry);
     registerBackendInstantiation(compiler.listClass, registry);
   }
@@ skipping 186 matching lines @@
           MessageKind kind =
               compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(library)
               ? MessageKind.MIRROR_IMPORT
               : MessageKind.MIRROR_IMPORT_NO_USAGE;
           compiler.withCurrentElement(library, () {
             compiler.reportInfo(importTag, kind);
           });
         }
       }
     }
+    if (true  && DUMP_DEPENDENCIES) {
+      String representation(object) {
+        return "'$object'";
+      }
+      EventSink<String> output = compiler.outputProvider("", "pl");
+      [compiler.enqueuer.resolution, compiler.enqueuer.codegen].forEach((e) {
+        Relations deps = e.dependencies;
+        for (String relation in deps.links.keys) {
+          output.add('${deps.prefix}_$relation().\n');
+        }
+      });
+      output.close();
+    }
   }
 
   Element getDartClass(Element element) {
     for (ClassElement dartClass in implementationClasses.keys) {
       if (element == implementationClasses[dartClass]) {
         return dartClass;
       }
     }
     return element;
   }
@@ skipping 642 matching lines @@
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }