dart2js cps: Use more precise type inference for direct index access.

pkg/compiler/lib/src/cps_ir/type_mask_system.dart

Index: pkg/compiler/lib/src/cps_ir/type_mask_system.dart
diff --git a/pkg/compiler/lib/src/cps_ir/type_mask_system.dart b/pkg/compiler/lib/src/cps_ir/type_mask_system.dart
index a5fa5a8dc9618e51ca53f4b51496735ff404cdbf..a57775db39d660f5fdac94e1fd9c6cc1f143634e 100644
--- a/pkg/compiler/lib/src/cps_ir/type_mask_system.dart
+++ b/pkg/compiler/lib/src/cps_ir/type_mask_system.dart
@@ -295,4 +295,31 @@ class TypeMaskSystem {
   TypeMask receiverTypeFor(Selector selector, TypeMask mask) {
     return classWorld.allFunctions.receiverType(selector, mask);
   }
+
+  /// The result of an index operation on something of [type], or the dynamic
+  /// type if unknown.
+  TypeMask getIndexType(TypeMask type) {

[sra1, 2015/09/15 15:59:32]

Is there a nice way to write this kind of function so that it works correctly
with unions and other composite representations?

[sra1, 2015/09/15 15:59:32]

'getIndexType' suggests to me the argument type of the indexer.

This function is not general purpose (used for GetIndex only, I assume that is
lowered only for indexable)
Perhaps rename to  elementTypeOfIndexable()

[asgerf, 2015/09/15 16:34:07]

I don't entirely understand the use of forwarding type masks, but the union
alone is almost a one-liner so I went ahead and added it here.

It would be nice with a map() function on TypeMask for something like this,
though, if only to signal that you are actually allowed to do it outside the
type inference phase.

@second comment: I agree, renamed.

+    if (type is ContainerTypeMask) {

[karlklose, 2015/09/15 08:17:07]

We should maybe use a predicate instead of the is check because we want to make
the interface for type inference more explicit so that we are able to change the
internal representation and inference algorithm.

[asgerf, 2015/09/15 10:46:14]

The idea is that TypeMaskSystem should be that interface (from the CPS's
viewpoint). I.e. its implementation depends on TypeMask, but its interface
should be implementable by an alternate type inference and given to the CPS.

It's not quite there yet, but that's the idea.

+      return type.elementType;
+    }
+    if (isDefinitelyString(type)) {
+      return stringType;
+    }
+    if (type.satisfies(backend.typedArrayClass, classWorld)) {
+      if (type.satisfies(backend.typedArrayOfIntClass, classWorld)) {
+        return intType;
+      }
+      return numType;
+    }
+    return dynamicType;
+  }
+
+  /// The length of something of [type], or `null` if unknown.
+  int getContainerLength(TypeMask type) {
+    if (type is ContainerTypeMask) {
+      return type.length;
+    } else {
+      return null;
+    }
+  }
 }