Track fields which are known to be always set to integer constants

lib/compiler/implementation/universe.dart

Index: lib/compiler/implementation/universe.dart
diff --git a/lib/compiler/implementation/universe.dart b/lib/compiler/implementation/universe.dart
index 635cd737cf1c19b9d2425842d930e1644221f751..c0daea7bfffa2a346c19479a28f326a4ce185f00 100644
--- a/lib/compiler/implementation/universe.dart
+++ b/lib/compiler/implementation/universe.dart
@@ -13,6 +13,8 @@ class Universe {
   final Map<SourceString, Set<Selector>> invokedSetters;
   final Map<SourceString, Set<Selector>> fieldGetters;
   final Map<SourceString, Set<Selector>> fieldSetters;
+  final Map<Element, Map<SourceString, bool>> fieldIntegerInitializers;
+  final Map<Element, Map<SourceString, bool>> fieldIntegerSetters;
   // TODO(ngeoffray): This should be a Set<Type>.
   final Set<Element> isChecks;
   final RuntimeTypeInformation rti;
@@ -27,6 +29,10 @@ class Universe {
                invokedSetters = new Map<SourceString, Set<Selector>>(),
                fieldGetters = new Map<SourceString, Set<Selector>>(),
                fieldSetters = new Map<SourceString, Set<Selector>>(),
+               fieldIntegerInitializers =
+                   new Map<Element, Map<SourceString, bool>>(),
+               fieldIntegerSetters =
+                   new Map<Element, Map<SourceString, bool>>(),
                isChecks = new Set<Element>(),
                rti = new RuntimeTypeInformation();
 
@@ -67,6 +73,62 @@ class Universe {
   bool hasFieldSetter(Element member, Compiler compiler) {
     return hasMatchingSelector(fieldSetters[member.name], member, compiler);
   }
+
+  void updateFieldIntegerInitializers(Type type,
+                                      SourceString name,
+                                      bool isInteger) {
+    Map<SourceString, bool> fields =
+        fieldIntegerInitializers.putIfAbsent(
+            type.element, () => new Map<SourceString, bool>());
+    if (!fields.containsKey(name)) {
+      fields[name] = isInteger;
+    } else {
+      fields[name] = fields[name] && isInteger;
+    }
+  }
+
+  bool couldHaveFieldOnlyIntegerInitializer(Type type, SourceString name) {
+    if (type == null) return false;
+    if (!fieldIntegerInitializers.containsKey(type.element)) return true;
+    Map<SourceString, bool> fields = fieldIntegerInitializers[type.element];
+    if (!fields.containsKey(name)) return false;
+    return fields[name];
+  }
+
+  bool hasFieldOnlyIntegerInitializer(Type type, SourceString name) {
+    if (type == null) return false;
+    if (!fieldIntegerInitializers.containsKey(type.element)) return false;
+    Map<SourceString, bool> fields = fieldIntegerInitializers[type.element];
+    if (!fields.containsKey(name)) return false;
+    return fields[name];
+  }
+
+  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 false;

[floitsch, 2012/06/15 15:00:50]

Why return false here?

[Søren Gjesse, 2012/06/18 11:32:17]

Yes that is a good question. For the current use I should return true, as I
check that it is also initialized to an integer and therefore if there are no
setters it will stay an integer. Changed it to true.

+    Map<SourceString, bool> fields = fieldIntegerSetters[type.element];
+    if (!fields.containsKey(name)) return false;
+    return fields[name];
+  }
 }
 
 class SelectorKind {