No globals.

dart/frog/leg/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 94 matching lines @@
   Element getEqualsInterceptor() {
     return compiler.findHelper(const SourceString('eq'));
   }
 
   Element getMapMaker() {
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
 }
 
 class SsaBuilderTask extends CompilerTask {
+  final Interceptors interceptors;
+  final Map<Node, ClosureData> closureDataCache;
+
+  String get name() => 'SSA builder';
+
   SsaBuilderTask(Compiler compiler)
-    : super(compiler), interceptors = new Interceptors(compiler);
-  String get name() => 'SSA builder';
-  Interceptors interceptors;
+    : interceptors = new Interceptors(compiler),
+      closureDataCache = new HashMap<Node, ClosureData>(),
+      super(compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
       FunctionElement element = work.element;
       HInstruction.idCounter = 0;
       SsaBuilder builder = new SsaBuilder(compiler, work);
       HGraph graph;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           graph = compileConstructor(builder, work);
@@ skipping 135 matching lines @@
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
     ClosureTranslator translator =
-        new ClosureTranslator(builder.compiler, builder.elements);
+        new ClosureTranslator(builder.compiler, builder.elements,
+                              builder.closureDataCache);
     closureData = translator.translate(node);
 
     FunctionParameters params = function.computeParameters(builder.compiler);
     params.forEachParameter((Element element) {
       HParameterValue parameter = new HParameterValue(element);
       builder.add(parameter);
       directLocals[element] = parameter;
     });
     if (closureData.thisElement !== null) {
       // Once closures have been mapped to classes their instance members might
@@ skipping 426 matching lines @@
 
 class SsaBuilder implements Visitor {
   final Compiler compiler;
   TreeElements elements;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
+  final Map<Node, ClosureData> closureDataCache;

[ngeoffray, 2012/03/23 07:57:02]

Since that guy is only used once in this file, I'd prefer avoiding a field.

[ahe, 2012/03/23 09:09:40]

I don't understand your concern. I think the field makes it easier to see how
the closureDataCache is used.

I would refactor this code much more aggressively, but I don't want to interfere
with the rest of you.

[ngeoffray, 2012/03/23 09:16:28]

My concern is: I don't like introducing fields, IMO it makes reading the class
more difficult. And writing compiler.builder.closureDataCache looks as good to
me than closureDataCache, especially when it's only used once.

[ahe, 2012/03/23 09:35:48]

Perhaps I should have said: I assume you want me to write
compiler.builder.closureDataCache, I don't understand why you would want that as
it makes it less obvious that this class is a user of closureDataCache.

I think it would better if this class referenced its task directly, instead of
compiler, but I'm not going to make this "big" refactoring as I don't want to
create too many conflicts at this point.

I have bigger ideas for where we could take Task and Compiler, but I would
prefer to discuss this in person.

 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
 
   SsaBuilder(Compiler compiler, WorkItem work)
     : this.compiler = compiler,
       this.work = work,
       interceptors = compiler.builder.interceptors,
+      closureDataCache = compiler.builder.closureDataCache,
       methodInterceptionEnabled = true,
       elements = work.resolutionTree,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       jumpTargets = new Map<TargetElement, JumpHandler>() {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
@@ skipping 2130 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }