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

lib/compiler/implementation/universe.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 Universe {
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
   final Map<SourceString, Set<Selector>> invokedNames;
   final Map<SourceString, Set<Selector>> invokedGetters;
   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;
 
   Universe() : generatedCode = new Map<Element, String>(),
                generatedBailoutCode = new Map<Element, String>(),
                instantiatedClasses = new Set<ClassElement>(),
                instantiatedClassInstanceFields = new Set<SourceString>(),
                staticFunctionsNeedingGetter = new Set<FunctionElement>(),
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
                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();
 
   void addGeneratedCode(WorkItem work, String code) {
     generatedCode[work.element] = code;
   }
 
   void addBailoutCode(WorkItem work, String code) {
     generatedBailoutCode[work.element] = code;
   }
@@ skipping 20 matching lines @@
     return hasMatchingSelector(invokedSetters[member.name], member, compiler);
   }
 
   bool hasFieldGetter(Element member, Compiler compiler) {
     return hasMatchingSelector(fieldGetters[member.name], member, compiler);
   }
 
   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 hasFieldOnlyIntegerInitializers(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];
+  }
+
+  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 SelectorKind {
   final String name;
   const SelectorKind(this.name);
 
   static final SelectorKind GETTER = const SelectorKind('getter');
   static final SelectorKind SETTER = const SelectorKind('setter');
   static final SelectorKind INVOCATION = const SelectorKind('invocation');
   static final SelectorKind OPERATOR = const SelectorKind('operator');
@@ skipping 265 matching lines @@
 
     return false;
   }
 
   bool operator ==(other) {
     if (other is !TypedSelector) return false;
     if (other.receiverType !== receiverType) return false;
     return super == other;
   }
 }