Refactor the collection of initializer list types

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;
@@ skipping 16 matching lines @@
   String run(Compiler compiler, Enqueuer world) {
     String code = world.universe.generatedCode[element];
     if (code !== null) return code;
     resolutionTree = compiler.analyze(this, world);
     return compiler.codegen(this, world);
   }
 }
 
 class Backend {
   final Compiler compiler;
+  final Map<Element, Map<SourceString, HType>> fieldInitializers;

[karlklose, 2012/06/19 15:07:40]

Why not move these datastructures to the JavaScriptBackend? The HTypes are JS
specific.

+  final Map<Element, Map<SourceString, bool>> fieldIntegerSetters;
 
-  Backend(this.compiler);
+  Backend(this.compiler)
+     : fieldInitializers = new Map<Element, Map<SourceString, HType>>(),
+       fieldIntegerSetters = new Map<Element, Map<SourceString, bool>>();
 
   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 void processNativeClasses(Enqueuer world,
                                      Collection<LibraryElement> libraries);
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
+
+  void updateFieldInitializers(Type type,
+                               SourceString name,
+                               HType propagatedType) {
+    Map<SourceString, HType> fields =
+        fieldInitializers.putIfAbsent(
+            type.element, () => new Map<SourceString, HType>());
+    if (!fields.containsKey(name)) {
+      fields[name] = propagatedType;
+    } else {
+      if (fields[name] != propagatedType) fields[name] = HType.UNKNOWN;
+    }
+  }
+
+  bool couldHaveFieldSingleTypeInitializers(Type type,
+                                            SourceString name,
+                                            HType requestedType) {
+    if (type == null) return false;
+    // If there is no information on the initializer it might still be
+    // initialized to integers only.
+    if (!fieldInitializers.containsKey(type.element)) return true;
+    Map<SourceString, HType> fields = fieldInitializers[type.element];
+    HType propagatedType = fields[name];
+    if (propagatedType == null) return true;
+    return propagatedType == requestedType;
+  }
+
+  bool hasFieldSingleTypeInitializers(Type type,
+                                      SourceString name,
+                                      HType requestedType) {
+    if (type == null) return false;
+    if (!fieldInitializers.containsKey(type.element)) return false;
+    Map<SourceString, HType> fields = fieldInitializers[type.element];
+    HType propagatedType = fields[name];
+    if (propagatedType == null) return false;
+    return propagatedType == requestedType;
+  }
+
+  void updateFieldIntegerSetters(Type type, SourceString name, bool isInteger) {
+    Map<SourceString, bool> fields =
+        fieldIntegerSetters.putIfAbsent(
+            type.element, () => new Map<SourceString, bool>());
+    if (!fields.containsKey(name)) {
+      fields[name] = isInteger;
+    } else {
+      fields[name] = fields[name] && isInteger;
+    }
+  }
+
+  bool couldHaveFieldOnlyIntegerSetters(Type type, SourceString name) {
+    if (type == null) return false;
+    if (!fieldIntegerSetters.containsKey(type.element)) return true;
+    Map<SourceString, bool> fields = fieldIntegerSetters[type.element];
+    if (!fields.containsKey(name)) return false;
+    return fields[name];
+  }
+
+  bool hasFieldOnlyIntegerSetters(Type type, SourceString name) {
+    if (type == null) return false;
+    if (!fieldIntegerSetters.containsKey(type.element)) return true;
+    Map<SourceString, bool> fields = fieldIntegerSetters[type.element];
+    if (!fields.containsKey(name)) return false;
+    return fields[name];
+  }
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
 
   List<CompilerTask> get tasks() {
     return <CompilerTask>[builder, optimizer, generator, emitter];
@@ skipping 702 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);
   }
 }