Associate partial source map with each code block in Universe.generatedCode.

lib/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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
 
 /**
  * If true, trace information on pass2 optimizations.
  */
 final bool REPORT_PASS2_OPTIMIZATIONS = false;
 
 class WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
   WorkItem(this.element, this.resolutionTree);
 
   bool isAnalyzed() => resolutionTree !== null;
 
   String run(Compiler compiler, Enqueuer world) {
-    String code = world.universe.generatedCode[element];
-    if (code !== null) return code;
+    CodeBlock codeBlock = world.universe.generatedCode[element];
+    if (codeBlock !== null) return codeBlock.code;
     resolutionTree = compiler.analyze(this, world);
     return compiler.codegen(this, world);
   }
 }
 
 class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   void enqueueAllTopLevelFunctions(LibraryElement lib, Enqueuer world) {
     lib.forEachExport((Element e) {
       if (e.isFunction()) world.addToWorkList(e);
     });
   }
 
   abstract void enqueueHelpers(Enqueuer world);
-  abstract String codegen(WorkItem work);
+  abstract CodeBlock codegen(WorkItem work);
   abstract void processNativeClasses(Enqueuer world,
                                      Collection<LibraryElement> libraries);
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
@@ skipping 21 matching lines @@
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
     enqueueAllTopLevelFunctions(compiler.interceptorsLibrary, world);
     for (var helper in [const SourceString('Closure'),
                         const SourceString('ConstantMap'),
                         const SourceString('ConstantProtoMap')]) {
       var e = compiler.findHelper(helper);
       if (e !== null) world.registerInstantiatedClass(e);
     }
   }
 
-  String codegen(WorkItem work) {
+  CodeBlock codegen(WorkItem work) {
     HGraph graph = builder.build(work);
     optimizer.optimize(work, graph);
     if (work.allowSpeculativeOptimization
         && optimizer.trySpeculativeOptimizations(work, graph)) {
-      String code = generator.generateBailoutMethod(work, graph);
-      compiler.codegenWorld.addBailoutCode(work, code);
+      CodeBlock codeBlock = generator.generateBailoutMethod(work, graph);
+      compiler.codegenWorld.addBailoutCode(work, codeBlock);
       optimizer.prepareForSpeculativeOptimizations(work, graph);
       optimizer.optimize(work, graph);
     }
     return generator.generateMethod(work, graph);
   }
 
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) {
     native.processNativeClasses(world, emitter, libraries);
   }
@@ skipping 467 matching lines @@
     });
     world.queueIsClosed = true;
     assert(world.checkNoEnqueuedInvokedInstanceMethods());
     world.registerFieldClosureInvocations();
   }
 
   void processRecompilationQueue(Enqueuer world) {
     assert(phase == PHASE_RECOMPILING);
     while (!world.recompilationCandidates.isEmpty()) {
       WorkItem work = world.recompilationCandidates.next();
-      String oldCode = world.universe.generatedCode[work.element];
+      String oldCode = world.universe.generatedCode[work.element].code;
       world.universe.generatedCode.remove(work.element);
       world.universe.generatedBailoutCode.remove(work.element);
       withCurrentElement(work.element, () => work.run(this, world));
-      String newCode = world.universe.generatedCode[work.element];
+      String newCode = world.universe.generatedCode[work.element].code;
       if (REPORT_PASS2_OPTIMIZATIONS && newCode != oldCode) {
         log("Pass 2 optimization:");
         log("Before:\n$oldCode");
         log("After:\n$newCode");
       }
     }
   }
 
   /**
    * Perform various checks of the queues. This includes checking that
@@ skipping 95 matching lines @@
         log('Compiled ${codegenWorld.generatedCode.length} methods.');
       } else {
         log('Recompiled ${world.recompilationCandidates.processed} methods.');
       }
       progress.reset();
     }
     if (work.element.kind.category == ElementCategory.VARIABLE) {
       constantHandler.compileWorkItem(work);
       return null;
     } else {
-      String code = backend.codegen(work);
-      codegenWorld.addGeneratedCode(work, code);
-      return code;
+      CodeBlock codeBlock = backend.codegen(work);
+      codegenWorld.addGeneratedCode(work, codeBlock);
+      return codeBlock.code;
     }
   }
 
   void registerInstantiatedClass(ClassElement cls) {
     enqueuer.resolution.registerInstantiatedClass(cls);
     enqueuer.codegen.registerInstantiatedClass(cls);
   }
 
   void resolveClass(ClassElement element) {
     withCurrentElement(element, () => resolver.resolveClass(element));
@@ skipping 166 matching lines @@
     // invariant that endOffset > beginOffset, but for EOF the
     // charoffset of the next token may be [beginOffset]. This can
     // also happen for synthetized tokens that are produced during
     // error handling.
     final endOffset =
       Math.max((end.next !== null) ? end.next.charOffset : 0, beginOffset + 1);
     assert(endOffset > beginOffset);
     return f(beginOffset, endOffset);
   }
 }