Improve tracking of the type of fields after object construction

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 39 matching lines @@
   abstract void assembleProgram();
   abstract List<CompilerTask> get tasks();
 }
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
   SsaCodeGeneratorTask generator;
   CodeEmitterTask emitter;
   final Map<Element, Map<Element, HType>> fieldInitializers;
+  final Map<Element, Map<Element, HType>> fieldConstructorSetters;

[floitsch, 2012/06/22 08:18:12]

Do we need this two-stage approach? Shouldn't it be enough to have a mapping
from FieldElement to HType?

[Søren Gjesse, 2012/06/22 09:22:36]

The reason for this is that we know that field will be called for all fields for
all constructors. For constructor bodies we cannot tell. Therefore I have this
special handling is a field is set in the constructor body and there is only one
constructor we can still do something.

   final Map<Element, Map<Element, bool>> fieldIntegerSetters;
 
   List<CompilerTask> get tasks() {
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : emitter = new CodeEmitterTask(compiler, generateSourceMap),
         fieldInitializers = new Map<Element, Map<Element, HType>>(),
+        fieldConstructorSetters = 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);
@@ skipping 56 matching lines @@
   bool hasFieldSingleTypeInitializers(Element field, HType requestedType) {
     assert(field.isField());
     assert(field.enclosingElement.isClass());
     if (!fieldInitializers.containsKey(field.enclosingElement)) return false;
     Map<Element, HType> fields = fieldInitializers[field.enclosingElement];
     HType propagatedType = fields[field];
     if (propagatedType == null) return false;
     return propagatedType == requestedType;
   }
 
+  void updateFieldConstructorSetters(Element field, HType type) {
+    assert(field.isField());
+    assert(field.enclosingElement.isClass());
+    Map<Element, HType> fields =
+        fieldConstructorSetters.putIfAbsent(
+          field.enclosingElement, () => new Map<Element, HType>());
+    if (!fields.containsKey(field)) {
+      fields[field] = type;
+    } else {
+      fields[field] = fields[field].union(type);
+    }
+  }
+
+  // Check if this field set in the constructor body.

[floitsch, 2012/06/22 08:18:12]

is set

[Søren Gjesse, 2012/06/22 09:22:36]

Done.

+  bool hasConstructorBodyFieldSetter(Element field) {
+    if (!fieldConstructorSetters.containsKey(field.enclosingElement)) {
+      return false;
+    }
+    return fieldConstructorSetters[field.enclosingElement][field] != null;
+  }
+
+  // Provide an optimistic estimate of the type of a field after construction.
+  // This only takes the initializer lists and field assignments in the
+  // constructor body into account. The constructor body might have method calls
+  // that could alter the field.
+  HType optimisticFieldTypeAfterConstruction(Element field) {
+    assert(field.isField());
+    assert(field.enclosingElement.isClass());
+
+    if (hasConstructorBodyFieldSetter(field)) {
+      // If there are field setters for this field in some constructor only one
+      // constructor then the type set will be the field type after
+      // construction.
+      if (field.enclosingElement.constructors.length == 1) {
+        return fieldConstructorSetters[field.enclosingElement][field];
+      } else {
+        return HType.UNKNOWN;
+      }
+    } else if (fieldInitializers.containsKey(field.enclosingElement)) {
+      HType type = fieldInitializers[field.enclosingElement][field];
+      return type == null ? HType.UNKNOWN : type;
+    } else {
+      return HType.UNKNOWN;
+    }
+  }
+
   void updateFieldIntegerSetters(Element field, bool isInteger) {
     assert(field.isField());
     assert(field.enclosingElement.isClass());
     Map<Element, bool> fields =
         fieldIntegerSetters.putIfAbsent(
           field.enclosingElement, () => new Map<Element, bool>());
     if (!fields.containsKey(field)) {
       fields[field] = isInteger;
     } else {
       fields[field] = fields[field] && isInteger;
@@ skipping 679 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);
   }
 }