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

sdk/lib/_internal/compiler/implementation/compiler.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 dart2js;
 
+// TODO(karlklose): move this to own library.
+
+class CallSite {
+  final TreeElements context;
+  final Send node;
+  CallSite(this.context, this.node);
+}
+
+class Dependency {
+  final CallSite site;
+  final Element target;
+  Dependency(this.site, this.target);
+}
+
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
 
 /**
  * Contains backend-specific data that is used throughout the compilation of
  * one work item.
  */
@@ skipping 33 matching lines @@
 // TODO(johnniwinther): Split this class into interface and implementation.
 // TODO(johnniwinther): Move this implementation to the JS backend.
 class CodegenRegistry extends Registry {
   final Compiler compiler;
   final TreeElements treeElements;
 
   CodegenRegistry(this.compiler, this.treeElements);
 
   bool get isForResolution => false;
 
+  Element get currentElement => treeElements.currentElement;
+
   // TODO(johnniwinther): Remove this getter when [Registry] creates a
   // dependency node.
   Setlet<Element> get otherDependencies => treeElements.otherDependencies;
 
   CodegenEnqueuer get world => compiler.enqueuer.codegen;
   js_backend.JavaScriptBackend get backend => compiler.backend;
 
   void registerDependency(Element element) {
     treeElements.registerDependency(element);
   }
 
   void registerInstantiatedClass(ClassElement element) {
     world.registerInstantiatedClass(element, this);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     world.registerInstantiatedType(type, this);
   }
 
   void registerStaticUse(Element element) {
     world.registerStaticUse(element);
   }
 
   void registerDynamicInvocation(Selector selector) {
-    world.registerDynamicInvocation(selector);
+    world.registerDynamicInvocation(currentElement, selector);
   }
 
   void registerDynamicSetter(Selector selector) {
-    world.registerDynamicSetter(selector);
+    world.registerDynamicSetter(currentElement, selector);
   }
 
   void registerDynamicGetter(Selector selector) {
-    world.registerDynamicGetter(selector);
+    world.registerDynamicGetter(currentElement, selector);
   }
 
   void registerGetterForSuperMethod(Element element) {
     world.registerGetterForSuperMethod(element);
   }
 
   void registerFieldGetter(Element element) {
     world.registerFieldGetter(element);
   }
 
@@ skipping 18 matching lines @@
 
   void registerGenericClosure(FunctionElement element) {
     backend.registerGenericClosure(element, world, this);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     world.registerGetOfStaticFunction(element);
   }
 
   void registerSelectorUse(Selector selector) {
-    world.registerSelectorUse(selector);
+    world.registerSelectorUse(currentElement, selector);
   }
 
   void registerFactoryWithTypeArguments() {
     world.registerFactoryWithTypeArguments(this);
   }
 
   void registerConstSymbol(String name) {
     backend.registerConstSymbol(name, this);
   }
 
@@ skipping 90 matching lines @@
   native.NativeEnqueuer nativeResolutionEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
   native.NativeEnqueuer nativeCodegenEnqueuer(world) {
     return new native.NativeEnqueuer();
   }
 
   void assembleProgram();
   List<CompilerTask> get tasks;
 
-  void onResolutionComplete() {}
+  void onResolutionComplete() {
+  }
 
   ItemCompilationContext createItemCompilationContext() {
     return new ItemCompilationContext();
   }
 
   bool classNeedsRti(ClassElement cls);
   bool methodNeedsRti(FunctionElement function);
 
 
   /// Called during codegen when [constant] has been used.
@@ skipping 91 matching lines @@
                               Registry registry) {}
   /**
    * Call this to register that the [:runtimeType:] property has been accessed.
    */
   void registerRuntimeType(Enqueuer enqueuer, Registry registry) {}
 
   /**
    * Call this method to enable [noSuchMethod] handling in the
    * backend.
    */
-  void enableNoSuchMethod(Enqueuer enqueuer) {
-    enqueuer.registerInvocation(compiler.noSuchMethodSelector);
+  void enableNoSuchMethod(context, Enqueuer enqueuer) {
+    // TODO(karlklose): add a context here.
+    enqueuer.registerInvocation(null, compiler.noSuchMethodSelector);
   }
 
   void registerRequiredType(DartType type, Element enclosingElement) {}
   void registerClassUsingVariableExpression(ClassElement cls) {}
 
   void registerConstSymbol(String name, Registry registry) {}
   void registerNewSymbol(Registry registry) {}
 
   /// Called when resolving the `Symbol` constructor.
   void onSymbolConstructor(Registry registry) {}
@@ skipping 946 matching lines @@
 
     log('Compiling...');
     phase = PHASE_COMPILING;
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport()) {
       enqueuer.codegen.addToWorkList(
           isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
       enqueuer.codegen.registerGetOfStaticFunction(main);
     }
     if (enabledNoSuchMethod) {
-      backend.enableNoSuchMethod(enqueuer.codegen);
+      backend.enableNoSuchMethod(null, enqueuer.codegen);
     }
     if (compileAll) {
       libraries.forEach((_, lib) => fullyEnqueueLibrary(lib,
           enqueuer.codegen));
     }
     processQueue(enqueuer.codegen, main);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
@@ skipping 619 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }
+
+// TODO(karlklose): rename to [CompilationInformation].
+class Relations {
+  final String prefix;
+
+  Relations(Enqueuer enqueuer)
+    : prefix = enqueuer.isResolutionQueue ? 'resolution' : 'codegen';
+
+  // General binary relations.  Relation X Target -> Source
+  Map<String, Map<dynamic, Set>> links = {};
+
+  Set<CallSite> callSites = new Set<CallSite>();
+
+  put(String relation, target, source) {
+    links.putIfAbsent(relation, () => {})
+        .putIfAbsent(target, () => new Set())
+        .add(source);
+  }
+
+  instantiates(InterfaceType type, Element source) {
+    assert(source is FunctionElement || source is VariableElement);
+    put('instantiates', type, source);
+  }
+
+  registerCallSite(TreeElements context, Send node) {
+    callSites.add(new CallSite(context, node));
+  }
+
+  enqueues(Element function, Element source) {
+    assert(source is Element || source is Element);
+    put('enqueues', function, source);    
+  }
+
+  void finalizeInformation(Compiler compiler) {
+    for (CallSite callSite in callSites) {
+      TreeElements context = callSite.context;
+      Selector selector = context.getSelector(callSite.node);
+      Element source = context.currentElement;
+      for (Element target in compiler.world.allFunctions.filter(selector)) {
+        put('calls', source, target);
+      }
+    }
+  }
+}