Start implementing checked mode and tools support for using it.

lib/compiler/implementation/ssa/types.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.
 
 abstract class HType {
   const HType();
 
-  factory HType.fromBoundedType(Type type, Compiler compiler) {
+  factory HType.fromBoundedType(Type type,

[floitsch, 2012/05/07 09:50:07]

/***/ doc explaining what boundedType means.

[ngeoffray, 2012/05/07 13:15:42]

Done.

+                                Compiler compiler,
+                                [bool canBeNull = false]) {
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("type variables");
     }
 
-    if (element === compiler.intClass) {
-      return HType.INTEGER;
-    } else if (element === compiler.numClass) {
-      return HType.NUMBER;
-    } else if (element === compiler.doubleClass) {
-      return HType.DOUBLE;
-    } else if (element === compiler.stringClass) {
-      return HType.STRING;
-    } else if (element === compiler.listClass
-               || Elements.isStringSupertype(element, compiler)
-               || Elements.isListSupertype(element, compiler)) {
-      return new HBoundedPotentialPrimitiveType(type);
+    if (!canBeNull) {
+      if (element === compiler.intClass) {
+        return HType.INTEGER;
+      } else if (element === compiler.numClass) {
+        return HType.NUMBER;
+      } else if (element === compiler.doubleClass) {
+        return HType.DOUBLE;
+      } else if (element === compiler.stringClass) {
+        return HType.STRING;
+      } else if (element === compiler.boolClass) {
+        return HType.BOOLEAN;
+      }
+    }
+    if (element === compiler.listClass
+        || Elements.isListSupertype(element, compiler)) {
+      return new HBoundedPotentialPrimitiveArray(type, canBeNull);
+    } else if (Elements.isStringSupertype(element, compiler)) {
+      return new HBoundedPotentialPrimitiveString(type, canBeNull);
+    } else if (element === compiler.objectClass
+               || element === compiler.dynamicClass) {
+      return null;
+    } else if (element === compiler.intClass
+               || element === compiler.boolClass
+               || element === compiler.numClass
+               || element === compiler.doubleClass
+               || element === compiler.stringClass) {
+      // TODO(ngeoffray): Create primitive nullable types.
+      return null;

[floitsch, 2012/05/07 09:50:07]

Please don't return 'null' from a factory.
I would prefer having a special Type node.

[ngeoffray, 2012/05/07 13:15:42]

I plan on changing that. I added a TODO here and where I do a null check.

     } else {
-      return new HBoundedType(type);
+      return new HBoundedType(type, canBeNull);
     }
   }
 
   static final HType CONFLICTING = const HAnalysisType("conflicting");
   static final HType UNKNOWN = const HAnalysisType("unknown");
   static final HType BOOLEAN = const HBooleanType();
   static final HType NUMBER = const HNumberType();
   static final HType INTEGER = const HIntegerType();
   static final HType DOUBLE = const HDoubleType();
   static final HType INDEXABLE_PRIMITIVE = const HIndexablePrimitiveType();
@@ skipping 283 matching lines @@
   HType intersection(HType other) {
     if (this === other || other.isUnknown()) return HType.EXTENDABLE_ARRAY;
     if (other.isString()) return HType.CONFLICTING;
     if (other.isIndexablePrimitive()) return HType.EXTENDABLE_ARRAY;
     return HType.CONFLICTING;
   }
 }
 
 class HBoundedType extends HType {
   final Type type;
+  final bool _canBeNull;
 
-  const HBoundedType(Type this.type);
+  bool canBeNull() => _canBeNull;
+
+  const HBoundedType(Type this.type, [bool this._canBeNull = false]);
   String toString() => type.toString();
 
   Type computeType(Compiler compiler) => type;
 
   HType combine(HType other) {
     if (other is HBoundedType) {
       HBoundedType temp = other;
       // Return [other] in case it is an exact type.
       if (this.type === temp.type) return other;
     }
@@ skipping 19 matching lines @@
   HType combine(HType other) {
     if (other.isExact()) {
       HExactType concrete = other;
       if (this.type === concrete.type) return this;
     }
     if (other.isUnknown()) return this;
     return HType.CONFLICTING;
   }
 }
 
-class HBoundedPotentialPrimitiveType extends HBoundedType {
-  const HBoundedPotentialPrimitiveType(Type type) : super(type);
+class HBoundedPotentialPrimitiveArray extends HBoundedType {
+  const HBoundedPotentialPrimitiveArray(Type type, bool canBeNull)
+      : super(type, canBeNull);
   bool canBePrimitive() => true;
+
+  HType combine(HType other) {
+    if (other.isReadableArray()) return other;
+    if (other.isIndexablePrimitive()) return HType.READABLE_ARRAY;
+    return super.combine(other);
+  }
 }
+
+class HBoundedPotentialPrimitiveString extends HBoundedType {
+  const HBoundedPotentialPrimitiveString(Type type, bool canBeNull)
+      : super(type, canBeNull);
+  bool canBePrimitive() => true;
+
+  HType combine(HType other) {
+    if (other.isString()) return other;
+    if (other.isIndexablePrimitive) return HType.STRING;
+    return super.combine(other);
+  }
+}