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 33 matching lines @@
   }
 
   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();
 }
 
 class JavaScriptBackend extends Backend {

[floitsch, 2012/06/20 10:20:33]

We should probably move the class out of the compiler file.
But in a different CL.

[Søren Gjesse, 2012/06/21 08:51:35]

Will do.

   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
+  final Map<Element, Map<Element, HType>> fieldInitializers;
+  final Map<Element, Map<Element, bool>> fieldIntegerSetters;
 
   List<CompilerTask> get tasks() {
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   JavaScriptBackend(Compiler compiler)
       : emitter = new CodeEmitterTask(compiler),
+        fieldInitializers = new Map<Element, Map<Element, HType>>(),
+        fieldIntegerSetters = new Map<Element, Map<Element, bool>>(),
         super(compiler) {
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
   }
 
   void enqueueHelpers(Enqueuer world) {
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
     enqueueAllTopLevelFunctions(compiler.interceptorsLibrary, world);
     for (var helper in [const SourceString('Closure'),
@@ skipping 18 matching lines @@
   }
 
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) {
     native.processNativeClasses(world, emitter, libraries);
   }
 
   void assembleProgram() {
     emitter.assembleProgram();
   }
+
+  void updateFieldInitializers(Type type,
+                               Element field,
+                               HType propagatedType) {
+    assert(field.isField());
+    Map<Element, HType> fields =
+        fieldInitializers.putIfAbsent(
+            type.element, () => new Map<Element, HType>());
+    if (!fields.containsKey(field)) {
+      fields[field] = propagatedType;
+    } else {
+      if (fields[field] != propagatedType) fields[field] = HType.UNKNOWN;

[floitsch, 2012/06/20 10:20:33]

can't you just union the types?

[Søren Gjesse, 2012/06/21 08:51:35]

Done, that should also be better.

+    }
+  }
+
+  bool couldHaveFieldSingleTypeInitializers(Type type,
+                                            Element field,
+                                            HType requestedType) {
+    assert(field.isField());
+    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<Element, HType> fields = fieldInitializers[type.element];
+    HType propagatedType = fields[field];
+    if (propagatedType == null) return true;
+    return propagatedType == requestedType;
+  }
+
+  bool hasFieldSingleTypeInitializers(Type type,
+                                      Element field,
+                                      HType requestedType) {
+    assert(field.isField());
+    if (type == null) return false;
+    if (!fieldInitializers.containsKey(type.element)) return false;
+    Map<Element, HType> fields = fieldInitializers[type.element];
+    HType propagatedType = fields[field];
+    if (propagatedType == null) return false;
+    return propagatedType == requestedType;
+  }
+
+  void updateFieldIntegerSetters(Type type, Element field, bool isInteger) {
+    assert(field.isField());
+    Map<Element, bool> fields =
+        fieldIntegerSetters.putIfAbsent(
+            type.element, () => new Map<Element, bool>());
+    if (!fields.containsKey(field)) {
+      fields[field] = isInteger;
+    } else {
+      fields[field] = fields[field] && isInteger;
+    }
+  }
+
+  bool couldHaveFieldOnlyIntegerSetters(Type type, Element field) {

[floitsch, 2012/06/20 10:20:33]

Doesn't the  field element contain the enclosing class? If yes it should be
enough to pass the field-element.

[Søren Gjesse, 2012/06/21 08:51:35]

It does. The element of the type can be a sub-class of the containing element
for the field, but that should be OK as we only use HFieldGet/Set when the field
name is unique in the class hierarchy.

+    assert(field.isField());
+    if (type == null) return false;
+    if (!fieldIntegerSetters.containsKey(type.element)) return true;
+    Map<Element, bool> fields = fieldIntegerSetters[type.element];
+    if (!fields.containsKey(field)) return false;
+    return fields[field];
+  }
+
+  bool hasFieldOnlyIntegerSetters(Type type, Element field) {

[floitsch, 2012/06/20 10:20:33]

I would remove this method. It is identical to the
couldHaveFieldOnlyIntegerSetters.
Also it is misleading. Even when returning true the field might still have
non-integer setters (if there are dynamic setters). So from this point of view
"couldHaveFieldOnly..." fills the role. I would also add a comment to couldHave
stating that it returns true if all seen (typed) setters have been integers.

[Søren Gjesse, 2012/06/21 08:51:35]

Changed the name to onlyFieldIntegerSettersSoFar (and dropped the other). Added
a comment. The name was supposed to indicate that the information is from
HFieldSet instructions only and does not include dynamic setters.

+    assert(field.isField());
+    if (type == null) return false;
+    if (!fieldIntegerSetters.containsKey(type.element)) return true;
+    Map<Element, bool> fields = fieldIntegerSetters[type.element];
+    if (!fields.containsKey(field)) return false;
+    return fields[field];
+  }
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   final bool enableTypeAssertions;
@@ skipping 428 matching lines @@
     checker.check(tree, elements);
     return elements;
   }
 
   TreeElements analyze(WorkItem work, Enqueuer world) {
     if (work.isAnalyzed()) return work.resolutionTree;
     if (progress.elapsedInMs() > 500) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
       if (phase == PHASE_RESOLVING) {
-        log('Resolved ${enqueuer.resolution.resolvedElements.length}'
+        log('Resolved ${enqueuer.resolution.resolvedElements.length} '
             'elements.');
         progress.reset();
       }
     }
     Element element = work.element;
     TreeElements result = world.getCachedElements(element);
     if (result !== null) return result;
     if (world !== enqueuer.resolution) {
       internalErrorOnElement(element,
                              'Internal error: unresolved element: $element.');
@@ skipping 201 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);
   }
 }