Optimize boolean asserts

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 91 matching lines @@
       res = new StackOverflowException();
     }
   }
   // TODO(jmesserly): setting the stack property is not a long term solution.
   // Also it causes the exception to print as if it were a TypeError or
   // RangeError, instead of using the proper toString.
   res.stack = e.stack;
   return res;
 }
 function $notnull_bool(test) {
-  return typeof(test) == 'boolean' ? test : test.is$bool();
+  return (test === true || test === false) ? test : test.is$bool();
 }
 function $assert(test, text, url, line, column) {
   if (typeof test == 'function') test = test();
   if (!test) $throw(new AssertError(text, url, line, column));
 }
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
@@ skipping 135 matching lines @@
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments) {
   this._receiver = _receiver;
   this._functionName = _functionName;
   this._arguments = _arguments;
   // Initializers done
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = 0;
-   $notnull_bool(i < this._arguments.length); i++) {
-    if ($notnull_bool(i > 0)) {
+   i < this._arguments.length; i++) {

[jimhug, 2011/11/12 00:26:36]

I love the improvements to this file.

+    if (i > 0) {
       sb.add(", ");
     }
     sb.add(this._arguments.$index(i));
   }
   sb.add("]");
   return ("NoSuchMethodException - receiver: '" + this._receiver + "' ") + ("function name: '" + this._functionName + "' arguments: [" + sb + "]");
 }
 // ********** Code for ObjectNotClosureException **************
 function ObjectNotClosureException() {}
 ObjectNotClosureException.prototype.toString = function() {
@@ skipping 614 matching lines @@
 ListFactory = Array;
 ListFactory.prototype.is$ListFactory = function(){return this;};
 ListFactory.prototype.is$List = function(){return this;};
 ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
 ListFactory.prototype.is$List$Definition = function(){return this;};
 ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
 ListFactory.prototype.is$List$String = function(){return this;};
 ListFactory.prototype.is$List$Type = function(){return this;};
 ListFactory.prototype.is$List$Value = function(){return this;};
 ListFactory.prototype.is$List$int = function(){return this;};
+ListFactory.prototype.is$Collection$Type = function(){return this;};
 ListFactory.prototype.is$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
   var list = [];
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.add(e);
   }
   return (list && list.is$ListFactory());
 }
 ListFactory.prototype.add = function(value) {
@@ skipping 43 matching lines @@
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.is$Iterator$T = function(){return this;};
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
-  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
+  if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
 function ImmutableList(length) {
   this._length = length;
   ListFactory$E.call(this, length);
   // Initializers done
 }
 /** Implements extends for Dart classes on JavaScript prototypes. */
 function $inherits(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }
 $inherits(ImmutableList, ListFactory$E);
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.length);
   for (var i = 0;
-   $notnull_bool(i < other.length); i++) {
+   i < other.length; i++) {
     list._setindex(i, other.$index(i));
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
 }
 ImmutableList.prototype.set$length = function(length) {
   $throw(const$14/*const IllegalAccessException()*/);
 }
@@ skipping 29 matching lines @@
   $throw(const$14/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.removeLast = function() {
   $throw(const$14/*const IllegalAccessException()*/);
 }
 // ********** Code for ImmutableMap **************
 function ImmutableMap(keyValuePairs) {
   this._internal = $map([]);
   // Initializers done
   for (var i = 0;
-   $notnull_bool(i < keyValuePairs.length); i += 2) {
+   i < keyValuePairs.length; i += 2) {
     this._internal.$setindex(keyValuePairs.$index(i), keyValuePairs.$index(i + 1));
   }
 }
 ImmutableMap.prototype.is$Map$Node$Element = function(){return this;};
 ImmutableMap.prototype.is$Map$String$Member = function(){return this;};
 ImmutableMap.prototype.$index = function(key) {
   return this._internal.$index(key);
 }
 ImmutableMap.prototype.isEmpty = function() {
   return this._internal.isEmpty();
@@ skipping 50 matching lines @@
     var truncated = (this < 0) ? Math.ceil(this) : Math.floor(this);
 
     if (truncated == -0.0) return 0;
     return truncated;
 }
 NumImplementation.prototype.toDouble = function() {
   return this + 0;
 }
 NumImplementation.prototype.compareTo = function(other) {
   var thisValue = this.toDouble();
-  if ($notnull_bool(thisValue < other)) {
+  if (thisValue < other) {
     return -1;
   }
-  else if ($notnull_bool(thisValue > other)) {
+  else if (thisValue > other) {
     return 1;
   }
-  else if ($notnull_bool(thisValue == other)) {
-    if ($notnull_bool(thisValue == 0)) {
+  else if (thisValue == other) {
+    if (thisValue == 0) {
       var thisIsNegative = this.isNegative();
       var otherIsNegative = other.isNegative();
-      if ($notnull_bool($eq(thisIsNegative, otherIsNegative))) return 0;
+      if ($eq(thisIsNegative, otherIsNegative)) return 0;
       if ($notnull_bool(thisIsNegative)) return -1;
       return 1;
     }
     return 0;
   }
-  else if ($notnull_bool(this.isNaN())) {
-    if ($notnull_bool(other.isNaN())) {
+  else if (this.isNaN()) {
+    if (other.isNaN()) {
       return 0;
     }
     return 1;
   }
   else {
     return -1;
   }
 }
 // ********** Code for ExceptionImplementation **************
 function ExceptionImplementation(_msg) {
   this._msg = _msg;
   // Initializers done
 }
 ExceptionImplementation.prototype.toString = function() {
-  return $notnull_bool((this._msg == null)) ? "Exception" : ("Exception: " + this._msg + "");
+  return (this._msg == null) ? "Exception" : ("Exception: " + this._msg + "");
 }
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$V(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 HashMapImplementation.prototype.is$HashMapImplementation = function(){return this;};
 HashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
@@ skipping 13 matching lines @@
   return hashCode & (length - 1);
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
-  while ($notnull_bool(true)) {
+  while (true) {
     var existingKey = this._keys.$index(hash);
-    if ($notnull_bool(existingKey == null)) {
-      if ($notnull_bool(insertionIndex < 0)) return hash;
+    if (existingKey == null) {
+      if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
-    else if ($notnull_bool($eq(existingKey, key))) {
+    else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ($notnull_bool((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey))) {
+    else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  while ($notnull_bool(true)) {
+  while (true) {
     var existingKey = this._keys.$index(hash);
-    if ($notnull_bool(existingKey == null)) return -1;
-    if ($notnull_bool($eq(existingKey, key))) return hash;
+    if (existingKey == null) return -1;
+    if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
-  if ($notnull_bool(newNumberOfEntries >= this._loadLimit)) {
+  if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
   var capacity = this._keys.length;
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
-  if ($notnull_bool(this._numberOfDeleted > numberOfFree)) {
+  if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.length);
   }
 }
 HashMapImplementation._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
   $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "hash_map_set.dart", 153, 12);
   var capacity = this._keys.length;
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory$V(newCapacity);
   for (var i = 0;
-   $notnull_bool(i < capacity); i++) {
+   i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if ($notnull_bool(key == null || key === HashMapImplementation._deletedKey)) {
+    if (key == null || key === HashMapImplementation._deletedKey) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = 0;
 }
 HashMapImplementation.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ($notnull_bool((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey))) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
-  if ($notnull_bool(index < 0)) return null;
+  if (index < 0) return null;
   return this._values.$index(index);
 }
 HashMapImplementation.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
-  if ($notnull_bool(index >= 0)) {
+  if (index >= 0) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
     this._keys.$setindex(index, HashMapImplementation._deletedKey);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
 Object.defineProperty(HashMapImplementation.prototype, "length", {
   get: HashMapImplementation.prototype.get$length
 });
 HashMapImplementation.prototype.forEach = function(f) {
   var length = this._keys.length;
   for (var i = 0;
-   $notnull_bool(i < length); i++) {
-    if ($notnull_bool((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey))) {
+   i < length; i++) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory$K(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.getValues = function() {
   var list = new ListFactory$V(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, value);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$E(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$E$E, HashMapImplementation);
 HashMapImplementation$E$E.prototype.is$Map$Node$Element = function(){return this;};
 HashMapImplementation$E$E.prototype.is$Map$String$Member = function(){return this;};
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
-  while ($notnull_bool(true)) {
+  while (true) {
     var existingKey = this._keys.$index(hash);
-    if ($notnull_bool(existingKey == null)) {
-      if ($notnull_bool(insertionIndex < 0)) return hash;
+    if (existingKey == null) {
+      if (insertionIndex < 0) return hash;
       return insertionIndex;
     }
-    else if ($notnull_bool($eq(existingKey, key))) {
+    else if ($eq(existingKey, key)) {
       return hash;
     }
-    else if ($notnull_bool((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey))) {
+    else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._probeForLookup = function(key) {
   var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  while ($notnull_bool(true)) {
+  while (true) {
     var existingKey = this._keys.$index(hash);
-    if ($notnull_bool(existingKey == null)) return -1;
-    if ($notnull_bool($eq(existingKey, key))) return hash;
+    if (existingKey == null) return -1;
+    if ($eq(existingKey, key)) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation$E$E.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
-  if ($notnull_bool(newNumberOfEntries >= this._loadLimit)) {
+  if (newNumberOfEntries >= this._loadLimit) {
     this._grow(this._keys.length * 2);
     return;
   }
   var capacity = this._keys.length;
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
-  if ($notnull_bool(this._numberOfDeleted > numberOfFree)) {
+  if (this._numberOfDeleted > numberOfFree) {
     this._grow(this._keys.length);
   }
 }
 HashMapImplementation$E$E._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation$E$E.prototype._grow = function(newCapacity) {
   $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "hash_map_set.dart", 153, 12);
   var capacity = this._keys.length;
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory$E(newCapacity);
   for (var i = 0;
-   $notnull_bool(i < capacity); i++) {
+   i < capacity; i++) {
     var key = oldKeys.$index(i);
-    if ($notnull_bool(key == null || key === HashMapImplementation._deletedKey)) {
+    if (key == null || key === HashMapImplementation._deletedKey) {
       continue;
     }
     var value = oldValues.$index(i);
     var newIndex = this._probeForAdding(key);
     this._keys.$setindex(newIndex, key);
     this._values.$setindex(newIndex, value);
   }
   this._numberOfDeleted = 0;
 }
 HashMapImplementation$E$E.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ($notnull_bool((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey))) {
+  if ((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey)) {
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation$E$E.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
-  if ($notnull_bool(index >= 0)) {
+  if (index >= 0) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
     this._keys.$setindex(index, HashMapImplementation._deletedKey);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation$E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation$E$E.prototype.forEach = function(f) {
   var length = this._keys.length;
   for (var i = 0;
-   $notnull_bool(i < length); i++) {
-    if ($notnull_bool((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey))) {
+   i < length; i++) {
+    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation$E$E.prototype.getKeys = function() {
   var list = new ListFactory$E(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
   }
   );
   return list;
 }
 HashMapImplementation$E$E.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 // ********** Code for HashMapImplementation$Element$HInstruction **************
 function HashMapImplementation$Element$HInstruction() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$HInstruction(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Element$HInstruction, HashMapImplementation);
 HashMapImplementation$Element$HInstruction.prototype.is$Map$Node$Element = false;
 HashMapImplementation$Element$HInstruction.prototype.is$Map$String$Member = false;
 HashMapImplementation$Element$HInstruction.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return (result && result.is$HashMapImplementation());
 }
 HashMapImplementation$Element$HInstruction._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
 function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$K$V(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V, HashMapImplementation);
 HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$Node$Element = false;
 HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$String$Member = false;
 HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element **************
 function HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$Node$Element(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element, HashMapImplementation);
 HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$Node$Element = false;
 HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$String$Member = false;
 HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword **************
 function HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, HashMapImplementation);
 HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$Node$Element = false;
 HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$EvaluatedValue **************
 function HashMapImplementation$String$EvaluatedValue() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$EvaluatedValue(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$EvaluatedValue, HashMapImplementation);
 HashMapImplementation$String$EvaluatedValue.prototype.is$Map$Node$Element = false;
 HashMapImplementation$String$EvaluatedValue.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$EvaluatedValue._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$String **************
 function HashMapImplementation$String$String() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$String(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$String, HashMapImplementation);
 HashMapImplementation$String$String.prototype.is$Map$Node$Element = false;
 HashMapImplementation$String$String.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$String._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Type$Type **************
 function HashMapImplementation$Type$Type() {
   // Initializers done
-  if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
+  if (HashMapImplementation._deletedKey == null) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$Type(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Type$Type, HashMapImplementation);
 HashMapImplementation$Type$Type.prototype.is$Map$Node$Element = false;
 HashMapImplementation$Type$Type.prototype.is$Map$String$Member = false;
 HashMapImplementation$Type$Type._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 HashSetImplementation.prototype.is$HashSetImplementation = function(){return this;};
+HashSetImplementation.prototype.is$Collection$Type = function(){return this;};
 HashSetImplementation.prototype.is$Iterable = function(){return this;};
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
   var set = new HashSetImplementation();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     set.add(e);
   }
   return (set && set.is$HashSetImplementation());
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
 HashSetImplementation.prototype.contains = function(value) {
   return this._backingMap.containsKey(value);
 }
 HashSetImplementation.prototype.remove = function(value) {
-  if ($notnull_bool(!$notnull_bool(this._backingMap.containsKey(value)))) return false;
+  if (!this._backingMap.containsKey(value)) return false;
   this._backingMap.remove(value);
   return true;
 }
 HashSetImplementation.prototype.addAll = function(collection) {
   var $this = this; // closure support
   collection.forEach(function _(value) {
     $this.add(value);
   }
   );
 }
 HashSetImplementation.prototype.forEach = function(f) {
   this._backingMap.forEach(function _(key, value) {
     f(key);
   }
   );
 }
 HashSetImplementation.prototype.filter = function(f) {
   var result = new HashSetImplementation$E();
   this._backingMap.forEach(function _(key, value) {
-    if ($notnull_bool(f(key))) result.add(key);
+    if (f(key)) result.add(key);
   }
   );
   return result;
 }
 HashSetImplementation.prototype.some = function(f) {
   var keys = this._backingMap.getKeys();
-  return keys.some(f);
+  return $assert_bool(keys.some(f));
 }
 HashSetImplementation.prototype.isEmpty = function() {
   return this._backingMap.isEmpty();
 }
 HashSetImplementation.prototype.get$length = function() {
   return this._backingMap.get$length();
 }
 Object.defineProperty(HashSetImplementation.prototype, "length", {
   get: HashSetImplementation.prototype.get$length
 });
 HashSetImplementation.prototype.iterator = function() {
   return new HashSetIterator$E(this);
 }
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
+HashSetImplementation$E.prototype.is$Collection$Type = function(){return this;};
 HashSetImplementation$E.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetImplementation$String **************
 function HashSetImplementation$String() {
   // Initializers done
   this._backingMap = new HashMapImplementation$String$String();
 }
 $inherits(HashSetImplementation$String, HashSetImplementation);
+HashSetImplementation$String.prototype.is$Collection$Type = false;
 HashSetImplementation$String.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetImplementation$Type **************
 function HashSetImplementation$Type() {
   // Initializers done
   this._backingMap = new HashMapImplementation$Type$Type();
 }
 $inherits(HashSetImplementation$Type, HashSetImplementation);
+HashSetImplementation$Type.prototype.is$Collection$Type = function(){return this;};
 HashSetImplementation$Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 HashSetIterator.prototype.is$Iterator$T = function(){return this;};
 HashSetIterator.prototype.hasNext = function() {
-  if ($notnull_bool(this._nextValidIndex >= this._entries.length)) return false;
-  if ($notnull_bool(this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey)) {
+  if (this._nextValidIndex >= this._entries.length) return false;
+  if (this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
-  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
+  if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
-    if ($notnull_bool(++this._nextValidIndex >= length)) break;
+    if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ($notnull_bool((entry == null) || (entry === deletedKey)))
+  while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for HashSetIterator$E **************
 function HashSetIterator$E(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 $inherits(HashSetIterator$E, HashSetIterator);
 HashSetIterator$E.prototype.is$Iterator$T = function(){return this;};
 HashSetIterator$E.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
-    if ($notnull_bool(++this._nextValidIndex >= length)) break;
+    if (++this._nextValidIndex >= length) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ($notnull_bool((entry == null) || (entry === deletedKey)))
+  while ((entry == null) || (entry === deletedKey))
 }
 // ********** Code for KeyValuePair **************
 function KeyValuePair(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
 KeyValuePair.prototype.get$value = function() { return this.value; };
 KeyValuePair.prototype.set$value = function(value) { return this.value = value; };
 // ********** Code for KeyValuePair$K$V **************
@@ skipping 11 matching lines @@
 $inherits(KeyValuePair$String$Keyword, KeyValuePair);
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   // Initializers done
   this._map = new HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V();
   this._list = new DoubleLinkedQueue$KeyValuePair$K$V();
 }
 LinkedHashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
 LinkedHashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
-  if ($notnull_bool(this._map.containsKey(key))) {
+  if (this._map.containsKey(key)) {
     this._map.$index(key).get$element().value = value;
   }
   else {
     this._list.addLast(new KeyValuePair$K$V(key, value));
     this._map.$setindex(key, this._list.lastEntry());
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
   var $0;
   var entry = (($0 = this._map.$index(key)) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
-  if ($notnull_bool(entry == null)) return null;
+  if (entry == null) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory$K(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   $assert(index == this.get$length(), "index == length", "linked_hash_map.dart", 75, 12);
@@ skipping 203 matching lines @@
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 DoubleLinkedQueue.prototype.is$DoubleLinkedQueue = function(){return this;};
+DoubleLinkedQueue.prototype.is$Collection$Type = function(){return this;};
 DoubleLinkedQueue.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue.DoubleLinkedQueue$from$factory = function(other) {
   var list = new DoubleLinkedQueue();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.addLast(e);
   }
   return (list && list.is$DoubleLinkedQueue());
 }
 DoubleLinkedQueue.prototype.addLast = function(value) {
@@ skipping 26 matching lines @@
   return counter;
 }
 Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
   get: DoubleLinkedQueue.prototype.get$length
 });
 DoubleLinkedQueue.prototype.isEmpty = function() {
   return (this._sentinel._next === this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
-  while ($notnull_bool(entry !== this._sentinel)) {
+  while (entry !== this._sentinel) {
     f(entry._element);
     entry = entry._next;
   }
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
-  while ($notnull_bool(entry !== this._sentinel)) {
-    if ($notnull_bool(f(entry._element))) return true;
+  while (entry !== this._sentinel) {
+    if (f(entry._element)) return true;
     entry = entry._next;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
   var other = new DoubleLinkedQueue$E();
   var entry = this._sentinel._next;
-  while ($notnull_bool(entry !== this._sentinel)) {
-    if ($notnull_bool(f(entry._element))) other.addLast(entry._element);
+  while (entry !== this._sentinel) {
+    if (f(entry._element)) other.addLast(entry._element);
     entry = entry._next;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator$E(this._sentinel);
 }
 // ********** Code for DoubleLinkedQueue$E **************
 function DoubleLinkedQueue$E() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 $inherits(DoubleLinkedQueue$E, DoubleLinkedQueue);
+DoubleLinkedQueue$E.prototype.is$Collection$Type = function(){return this;};
 DoubleLinkedQueue$E.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$KeyValuePair$K$V **************
 function DoubleLinkedQueue$KeyValuePair$K$V() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V();
 }
 $inherits(DoubleLinkedQueue$KeyValuePair$K$V, DoubleLinkedQueue);
+DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
-  while ($notnull_bool(entry !== this._sentinel)) {
+  while (entry !== this._sentinel) {
     f(entry._element);
     entry = entry._next;
   }
 }
 // ********** Code for DoubleLinkedQueue$KeyValuePair$Node$Element **************
 function DoubleLinkedQueue$KeyValuePair$Node$Element() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element();
 }
 $inherits(DoubleLinkedQueue$KeyValuePair$Node$Element, DoubleLinkedQueue);
+DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$KeyValuePair$Node$Element.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$KeyValuePair$String$Keyword **************
 function DoubleLinkedQueue$KeyValuePair$String$Keyword() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword();
 }
 $inherits(DoubleLinkedQueue$KeyValuePair$String$Keyword, DoubleLinkedQueue);
+DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$SourceString **************
 function DoubleLinkedQueue$SourceString() {}
 $inherits(DoubleLinkedQueue$SourceString, DoubleLinkedQueue);
+DoubleLinkedQueue$SourceString.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$SourceString.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue$SourceString.DoubleLinkedQueue$from$factory = function(other) {
   var list = new DoubleLinkedQueue();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.addLast(e);
   }
   return (list && list.is$DoubleLinkedQueue());
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.is$Iterator$T = function(){return this;};
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
-  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
+  if (!this.hasNext()) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 // ********** Code for _DoubleLinkedQueueIterator$E **************
 function _DoubleLinkedQueueIterator$E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 $inherits(_DoubleLinkedQueueIterator$E, _DoubleLinkedQueueIterator);
 _DoubleLinkedQueueIterator$E.prototype.is$Iterator$T = function(){return this;};
 // ********** Code for StopWatchImplementation **************
 function StopWatchImplementation() {
   this._start = null;
   this._stop = null;
   // Initializers done
 }
 StopWatchImplementation.prototype.start = function() {
-  if ($notnull_bool(this._start == null)) {
+  if (this._start == null) {
     this._start = Clock.now();
   }
   else {
-    if ($notnull_bool(this._stop == null)) {
+    if (this._stop == null) {
       return;
     }
     this._start = Clock.now() - (this._stop - this._start);
   }
 }
 StopWatchImplementation.prototype.stop = function() {
-  if ($notnull_bool(this._start == null)) {
+  if (this._start == null) {
     return;
   }
   this._stop = Clock.now();
 }
 StopWatchImplementation.prototype.elapsed = function() {
-  if ($notnull_bool(this._start == null)) {
+  if (this._start == null) {
     return 0;
   }
-  return $notnull_bool((this._stop == null)) ? (Clock.now() - this._start) : (this._stop - this._start);
+  return (this._stop == null) ? (Clock.now() - this._start) : (this._stop - this._start);
 }
 StopWatchImplementation.prototype.elapsedInMs = function() {
   return $truncdiv((this.elapsed() * 1000), this.frequency());
 }
 StopWatchImplementation.prototype.frequency = function() {
   return Clock.frequency();
 }
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
   // Initializers done
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
 Object.defineProperty(StringBufferImpl.prototype, "length", {
   get: StringBufferImpl.prototype.get$length
 });
 StringBufferImpl.prototype.isEmpty = function() {
   return this._length == 0;
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString();
-  if ($notnull_bool(str == null || str.isEmpty())) return this;
+  if (str == null || str.isEmpty()) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
   for (var $i = objects.iterator(); $i.hasNext(); ) {
     var obj = $i.next();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new ListFactory$String();
   this._length = 0;
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
-  if ($notnull_bool(this._buffer.length == 0)) return "";
-  if ($notnull_bool(this._buffer.length == 1)) return $assert_String(this._buffer.$index(0));
+  if (this._buffer.length == 0) return "";
+  if (this._buffer.length == 1) return $assert_String(this._buffer.$index(0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     var length = charCodes.length;
     var tmp = new Array(length);
     for (var i = 0; i < length; i++) {
       tmp[i] = charCodes.$index(i);
     }
     charCodes = tmp;
   }
   return String.fromCharCode.apply(null, charCodes);
 }
 StringBase.join = function(strings, separator) {
-  if ($notnull_bool(strings.length == 0)) return '';
+  if (strings.length == 0) return '';
   var s = $assert_String(strings.$index(0));
   for (var i = 1;
-   $notnull_bool(i < strings.length); i++) {
+   i < strings.length; i++) {
     s = s + separator + strings.$index(i);
   }
   return s;
 }
 StringBase.concatAll = function(strings) {
   return StringBase.join(strings, "");
 }
 // ********** Code for StringImplementation **************
 StringImplementation = String;
 StringImplementation.prototype.endsWith = function(other) {
@@ skipping 39 matching lines @@
 function Collections() {}
 Collections.forEach = function(iterable, f) {
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     f(e);
   }
 }
 Collections.some = function(iterable, f) {
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
-    if ($notnull_bool(f(e))) return true;
+    if (f(e)) return true;
   }
   return false;
 }
 Collections.filter = function(source, destination, f) {
   for (var $i = source.iterator(); $i.hasNext(); ) {
     var e = $i.next();
-    if ($notnull_bool(f(e))) destination.add(e);
+    if (f(e)) destination.add(e);
   }
   return destination;
 }
 // ********** Code for DateImplementation **************
 function DateImplementation() {}
 DateImplementation.fromEpoch$ctor = function(value, timeZone) {
   this.value = value;
   this.timeZone = timeZone;
   // Initializers done
 }
 DateImplementation.fromEpoch$ctor.prototype = DateImplementation.prototype;
 DateImplementation.now$ctor = function() {
   this.timeZone = new TimeZoneImplementation.local$ctor();
   this.value = DateImplementation._now();
   // Initializers done
   this._asJs();
 }
 DateImplementation.now$ctor.prototype = DateImplementation.prototype;
 DateImplementation.prototype.get$value = function() { return this.value; };
 DateImplementation.prototype.$eq = function(other) {
-  if ($notnull_bool(!$notnull_bool(((other instanceof DateImplementation))))) return false;
-  return $notnull_bool((this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone)));
+  if (!((other instanceof DateImplementation))) return false;
+  return (this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone));
 }
 DateImplementation.prototype.compareTo = function(other) {
   return this.value.compareTo(other.value);
 }
 DateImplementation.prototype.get$year = function() {
   return this.isUtc ? this._asJs().getUTCFullYear() :
       this._asJs().getFullYear();
 }
 DateImplementation.prototype.get$month = function() {
   return this.isUtc ? this._asJs().getMonth() + 1 :
@@ skipping 10 matching lines @@
 }
 DateImplementation.prototype.get$seconds = function() {
   return this.isUtc ? this._asJs().getUTCSeconds() : this._asJs().getSeconds()
 }
 DateImplementation.prototype.get$milliseconds = function() {
   return this.isUtc ? this._asJs().getUTCMilliseconds() :
       this._asJs().getMilliseconds();
 }
 DateImplementation.prototype.toString = function() {
   function threeDigits(n) {
-    if ($notnull_bool(n >= 100)) return ("" + n + "");
-    if ($notnull_bool(n > 10)) return ("0" + n + "");
+    if (n >= 100) return ("" + n + "");
+    if (n > 10) return ("0" + n + "");
     return ("00" + n + "");
   }
   function twoDigits(n) {
-    if ($notnull_bool(n >= 10)) return ("" + n + "");
+    if (n >= 10) return ("" + n + "");
     return ("0" + n + "");
   }
   var m = twoDigits(this.get$month());
   var d = twoDigits(this.get$day());
   var h = twoDigits(this.get$hours());
   var min = twoDigits(this.get$minutes());
   var sec = twoDigits(this.get$seconds());
   var ms = threeDigits(this.get$milliseconds());
   if ($notnull_bool(this.timeZone.isUtc)) {
     return ("" + this.get$year() + "-" + m + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + "Z");
@@ skipping 15 matching lines @@
     return this.date;
 }
 // ********** Code for TimeZoneImplementation **************
 function TimeZoneImplementation() {}
 TimeZoneImplementation.local$ctor = function() {
   this.isUtc = false;
   // Initializers done
 }
 TimeZoneImplementation.local$ctor.prototype = TimeZoneImplementation.prototype;
 TimeZoneImplementation.prototype.$eq = function(other) {
-  if ($notnull_bool(!$notnull_bool(((other instanceof TimeZoneImplementation))))) return false;
+  if (!((other instanceof TimeZoneImplementation))) return false;
   return $eq(this.isUtc, other.isUtc);
 }
 TimeZoneImplementation.prototype.toString = function() {
   if ($notnull_bool(this.isUtc)) return "TimeZone (UTC)";
   return "TimeZone (Local)";
 }
 // ********** Code for top level **************
 //  ********** Library node **************
 //  ********** Natives io_node.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
@@ skipping 25 matching lines @@
   return {'require': require, 'process': process, 'console': console,
         'setTimeout': setTimeout, 'clearTimeout': clearTimeout};
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split('/');
   var $list = path2.split('/');
   for (var $i = 0;$i < $list.length; $i++) {
     var piece = $list.$index($i);
-    if ($notnull_bool($eq(piece, '..') && pieces.length > 0) && $ne(pieces.last(), '.') && $ne(pieces.last(), '..')) {
+    if ($notnull_bool($notnull_bool($notnull_bool($eq(piece, '..') && pieces.length > 0) && $ne(pieces.last(), '.')) && $ne(pieces.last(), '..'))) {
       pieces.removeLast();
     }
     else if ($notnull_bool($ne(piece, ''))) {
       if ($notnull_bool(pieces.length > 0 && $eq(pieces.last(), '.'))) {
         pieces.removeLast();
       }
       pieces.add(piece);
     }
   }
   return Strings.join((pieces && pieces.is$List$String()), '/');
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if ($notnull_bool(lastSlash == -1)) {
+  if (lastSlash == -1) {
     return '.';
   }
   else {
     return path.substring(0, lastSlash);
   }
 }
 function basename(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if ($notnull_bool(lastSlash == -1)) {
+  if (lastSlash == -1) {
     return path;
   }
   else {
     return path.substring(lastSlash + 1);
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
   // Initializers done
@@ skipping 12 matching lines @@
 // ********** Code for top level **************
 function join(strings) {
   return Strings.join(strings, '/');
 }
 function readSync(fileName) {
   return new SourceFile(fileName, world.files.readAll(fileName));
 }
 //  ********** Library util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
-LinkFactory.Link$factory = function(head, tail) {
+LinkFactory.createLink = function(head, tail) {
   var $0;
-  return new LinkEntry(head, (($0 = $notnull_bool((tail == null)) ? const$16/*const EmptyLink()*/ : tail) && $0.is$Link$T()));
+  return new LinkEntry(head, (($0 = (tail == null) ? const$16/*const EmptyLink()*/ : tail) && $0.is$Link$T()));
 }
 // ********** Code for AbstractLink **************
 function AbstractLink() {}
 AbstractLink.prototype.is$Link = function(){return this;};
 AbstractLink.prototype.is$Link$Element = function(){return this;};
 AbstractLink.prototype.is$Link$Node = function(){return this;};
 AbstractLink.prototype.is$Link$T = function(){return this;};
 AbstractLink.prototype.is$Link$Token = function(){return this;};
 AbstractLink.prototype.is$Link$Type = function(){return this;};
 AbstractLink.prototype.is$Iterable = function(){return this;};
 AbstractLink.prototype.get$head = function() {
   $throw("bug");
 }
 AbstractLink.prototype.get$tail = function() {
   $throw("bug");
 }
 AbstractLink.prototype.prepend = function(element) {
-  return LinkFactory.Link$factory(element, this);
+  return LinkFactory.createLink(element, this);
 }
 AbstractLink.prototype.iterator = function() {
   var $0;
   return (($0 = this.toList().iterator()) && $0.is$Iterator$T());
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
   var $0;
   if ($notnull_bool(this.isEmpty())) return;
-  buffer.add($notnull_bool(this.get$head() == null) ? 'null' : this.get$head());
-  if ($notnull_bool(separatedBy == null)) separatedBy = '';
+  buffer.add(this.get$head() == null ? 'null' : this.get$head());
+  if (separatedBy == null) separatedBy = '';
   for (var link = (($0 = this.get$tail()) && $0.is$Link());
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link())) {
     buffer.add(separatedBy);
-    buffer.add($notnull_bool(link.get$head() == null) ? 'null' : link.get$head());
+    buffer.add(link.get$head() == null ? 'null' : link.get$head());
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 // ********** Code for AbstractLink$T **************
@@ skipping 57 matching lines @@
 LinkEntry.prototype.get$tail = function() {
   return this.realTail;
 }
 LinkEntry.prototype.isEmpty = function() {
   return false;
 }
 LinkEntry.prototype.toList = function() {
   var $0;
   var list = new ListFactory$T();
   for (var link = this;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
     list.addLast(link.get$head());
   }
   return list;
 }
 // ********** Code for LinkEntry$T **************
 function LinkEntry$T(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
 $inherits(LinkEntry$T, LinkEntry);
 // ********** Code for LinkBuilderImplementation **************
 function LinkBuilderImplementation() {
   this.head = null
   this.lastLink = null
   // Initializers done
 }
 LinkBuilderImplementation.prototype.get$head = function() { return this.head; };
 LinkBuilderImplementation.prototype.set$head = function(value) { return this.head = value; };
 LinkBuilderImplementation.prototype.toLink = function() {
-  if ($notnull_bool(this.head == null)) return const$16/*const EmptyLink()*/;
+  if (this.head == null) return const$16/*const EmptyLink()*/;
   this.lastLink.realTail = const$16/*const EmptyLink()*/;
   var link = this.head;
   this.lastLink = null;
   this.head = null;
   return link;
 }
 LinkBuilderImplementation.prototype.addLast = function(t) {
   var entry = new LinkEntry$T(t, null);
-  if ($notnull_bool(this.head == null)) {
+  if (this.head == null) {
     this.head = entry;
   }
   else {
     this.lastLink.realTail = entry;
   }
   this.lastLink = entry;
 }
 // ********** Code for LinkBuilderImplementation$Type **************
 function LinkBuilderImplementation$Type() {
   this.head = null
@@ skipping 22 matching lines @@
 ArrayBasedScanner.prototype.get$tail = function() { return this.tail; };
 ArrayBasedScanner.prototype.set$tail = function(value) { return this.tail = value; };
 ArrayBasedScanner.prototype.get$byteOffset = function() { return this.byteOffset; };
 ArrayBasedScanner.prototype.set$byteOffset = function(value) { return this.byteOffset = value; };
 ArrayBasedScanner.prototype.advance = function() {
   var next = this.nextByte();
   return next;
 }
 ArrayBasedScanner.prototype.select = function(choice, yes, no) {
   var next = this.advance();
-  if ($notnull_bool(next === choice)) {
+  if (next === choice) {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, yes);
     return this.advance();
   }
   else {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, no);
     return next;
   }
 }
 ArrayBasedScanner.prototype.appendStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
@@ skipping 17 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
-    if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
+    if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
-  if ($notnull_bool(this.groupingStack.get$head().kind !== openKind)) {
-    if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
+  if (this.groupingStack.get$head().kind !== openKind) {
+    if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
   this.groupingStack.get$head().endGroup = oldTail.next;
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
@@ skipping 34 matching lines @@
   // Initializers done
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$SourceString, ArrayBasedScanner);
 ArrayBasedScanner$SourceString.prototype.advance = function() {
   var next = this.nextByte();
   return next;
 }
 ArrayBasedScanner$SourceString.prototype.select = function(choice, yes, no) {
   var next = this.advance();
-  if ($notnull_bool(next === choice)) {
+  if (next === choice) {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, yes);
     return this.advance();
   }
   else {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, no);
     return next;
   }
 }
 ArrayBasedScanner$SourceString.prototype.appendStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
@@ skipping 17 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner$SourceString.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner$SourceString.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
-    if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
+    if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
-  if ($notnull_bool(this.groupingStack.get$head().kind !== openKind)) {
-    if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
+  if (this.groupingStack.get$head().kind !== openKind) {
+    if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
   this.groupingStack.get$head().endGroup = oldTail.next;
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
@@ skipping 19 matching lines @@
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
   if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
     this.groupingStack.get$head().endGroup = oldTail.next;
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenize = function() {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
+  while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 ArrayBasedScanner$SourceString.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
@@ skipping 199 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         return -1;
       }
-      if ($notnull_bool(next < 0x1f)) {
+      if (next < 0x1f) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeTag = function(next) {
-  if ($notnull_bool(this.byteOffset == 0)) {
-    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
+  if (this.byteOffset == 0) {
+    if (this.peek() == 33/*null.$BANG*/) {
       do {
         next = this.advance();
       }
-      while ($notnull_bool(next != 10/*null.$LF*/ && next != 13/*null.$CR*/))
+      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeTilde = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+  if (next == 47/*null.$SLASH*/) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
+  if (next == 93/*null.$RBRACKET*/) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendBeginGroup(91/*null.LBRACKET_TOKEN*/, "[");
     return next;
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
@@ skipping 78 matching lines @@
 
     default:
 
       this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
       return next;
 
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeEquals = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.GT_TOKEN*/, ">=");
       return this.advance();
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.GT_TOKEN*/, ">>=");
           return this.advance();
 
         case 62/*null.$GT*/:
 
           {
             next = this.advance();
-            if ($notnull_bool(next === 61/*null.$EQ*/)) {
+            if (next === 61/*null.$EQ*/) {
               this.appendStringToken(62/*null.GT_TOKEN*/, ">>>=");
               return this.advance();
             }
             else {
               this.appendGtGtGt(62/*null.GT_TOKEN*/, ">>>");
               return next;
             }
           }
 
         default:
@@ skipping 25 matching lines @@
 
     default:
 
       this.appendBeginGroup(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeNumber = function(next) {
   var start = this.byteOffset;
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 16 matching lines @@
       default:
 
         this.appendByteStringToken(105/*null.INT_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
-  if ($notnull_bool(x == 120/*null.$x*/ || x == 88/*null.$X*/)) {
+  if (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeHex = function(next) {
   var start = this.byteOffset;
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 10 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.byteOffset;
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!$notnull_bool(done))) {
+  while (!$notnull_bool(done)) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
-  if ($notnull_bool(next == 100/*null.$d*/ || next == 68/*null.$D*/)) {
+  if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
     next = this.advance();
   }
   this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeExponent = function(next) {
-  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
+  if (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
     next = this.advance();
   }
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 12 matching lines @@
       return this.advance();
 
     default:
 
       this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
       return next;
 
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeSingleLineComment = function(next) {
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case -1:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+        if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if ($notnull_bool(next == -1)) {
+        else if (next == -1) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeIdentifier = function(next) {
   var start = this.byteOffset;
   var state = null;
-  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+  if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while ($notnull_bool(true)) {
-    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
-      if ($notnull_bool(state != null)) {
+  while (true) {
+    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+      if (state != null) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
+    else if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
-    else if ($notnull_bool(next < 128)) {
+    else if (next < 128) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.byteOffset;
       do {
         next = this.nextByte();
       }
-      while ($notnull_bool(next > 127))
+      while (next > 127)
       var string = this.utf8String(nonAsciiStart, -1).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeRawString = function(next) {
   var start = this.byteOffset;
   next = this.advance();
-  if ($notnull_bool(next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/)) {
+  if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
-  if ($notnull_bool(q == next)) {
+  if (q == next) {
     next = this.advance();
-    if ($notnull_bool(q == next)) {
+    if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
   if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
+    else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 ArrayBasedScanner$SourceString.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q)) {
+  while (next != -1) {
+    if (next == q) {
       next = this.advance();
-      if ($notnull_bool(next == q)) {
+      if (next == q) {
         next = this.advance();
-        if ($notnull_bool(next == q)) {
+        if (next == q) {
           this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {}
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
+  while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 AbstractScanner.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
@@ skipping 199 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         return -1;
       }
-      if ($notnull_bool(next < 0x1f)) {
+      if (next < 0x1f) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner.prototype.tokenizeTag = function(next) {
-  if ($notnull_bool(this.get$byteOffset() == 0)) {
-    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
+  if (this.get$byteOffset() == 0) {
+    if (this.peek() == 33/*null.$BANG*/) {
       do {
         next = this.advance();
       }
-      while ($notnull_bool(next != 10/*null.$LF*/ && next != 13/*null.$CR*/))
+      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
 AbstractScanner.prototype.tokenizeTilde = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+  if (next == 47/*null.$SLASH*/) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
 AbstractScanner.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
+  if (next == 93/*null.$RBRACKET*/) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendBeginGroup(91/*null.LBRACKET_TOKEN*/, "[");
     return next;
   }
 }
 AbstractScanner.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
@@ skipping 78 matching lines @@
 
     default:
 
       this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
 AbstractScanner.prototype.tokenizeEquals = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
 AbstractScanner.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.GT_TOKEN*/, ">=");
       return this.advance();
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.GT_TOKEN*/, ">>=");
           return this.advance();
 
         case 62/*null.$GT*/:
 
           {
             next = this.advance();
-            if ($notnull_bool(next === 61/*null.$EQ*/)) {
+            if (next === 61/*null.$EQ*/) {
               this.appendStringToken(62/*null.GT_TOKEN*/, ">>>=");
               return this.advance();
             }
             else {
               this.appendGtGtGt(62/*null.GT_TOKEN*/, ">>>");
               return next;
             }
           }
 
         default:
@@ skipping 25 matching lines @@
 
     default:
 
       this.appendBeginGroup(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 16 matching lines @@
       default:
 
         this.appendByteStringToken(105/*null.INT_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
-  if ($notnull_bool(x == 120/*null.$x*/ || x == 88/*null.$X*/)) {
+  if (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
 AbstractScanner.prototype.tokenizeHex = function(next) {
   var start = this.get$byteOffset();
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 10 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!$notnull_bool(done))) {
+  while (!$notnull_bool(done)) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
-  if ($notnull_bool(next == 100/*null.$d*/ || next == 68/*null.$D*/)) {
+  if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
     next = this.advance();
   }
   this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
 AbstractScanner.prototype.tokenizeExponent = function(next) {
-  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
+  if (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
     next = this.advance();
   }
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 12 matching lines @@
       return this.advance();
 
     default:
 
       this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineComment = function(next) {
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case -1:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+        if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if ($notnull_bool(next == -1)) {
+        else if (next == -1) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeIdentifier = function(next) {
   var start = this.get$byteOffset();
   var state = null;
-  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+  if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while ($notnull_bool(true)) {
-    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
-      if ($notnull_bool(state != null)) {
+  while (true) {
+    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+      if (state != null) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
+    else if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
-    else if ($notnull_bool(next < 128)) {
+    else if (next < 128) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
-      while ($notnull_bool(next > 127))
+      while (next > 127)
       var string = $assert_String(this.utf8String(nonAsciiStart, -1).toString());
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
-  if ($notnull_bool(next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/)) {
+  if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
 AbstractScanner.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
-  if ($notnull_bool(q == next)) {
+  if (q == next) {
     next = this.advance();
-    if ($notnull_bool(q == next)) {
+    if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
   if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
+    else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q)) {
+  while (next != -1) {
+    if (next == q) {
       next = this.advance();
-      if ($notnull_bool(next == q)) {
+      if (next == q) {
         next = this.advance();
-        if ($notnull_bool(next == q)) {
+        if (next == q) {
           this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for AbstractScanner$S **************
 function AbstractScanner$S() {}
 $inherits(AbstractScanner$S, AbstractScanner);
 AbstractScanner$S.prototype.tokenize = function() {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
+  while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 AbstractScanner$S.prototype.bigSwitch = function(next) {
   this.beginToken();
   switch (next) {
     case 9/*null.$TAB*/:
     case 10/*null.$LF*/:
@@ skipping 199 matching lines @@
     case 118/*null.$v*/:
     case 119/*null.$w*/:
     case 120/*null.$x*/:
     case 121/*null.$y*/:
     case 122/*null.$z*/:
 
       return this.tokenizeIdentifier(next);
 
     default:
 
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         return -1;
       }
-      if ($notnull_bool(next < 0x1f)) {
+      if (next < 0x1f) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner$S.prototype.tokenizeTag = function(next) {
-  if ($notnull_bool(this.get$byteOffset() == 0)) {
-    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
+  if (this.get$byteOffset() == 0) {
+    if (this.peek() == 33/*null.$BANG*/) {
       do {
         next = this.advance();
       }
-      while ($notnull_bool(next != 10/*null.$LF*/ && next != 13/*null.$CR*/))
+      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
 AbstractScanner$S.prototype.tokenizeTilde = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+  if (next == 47/*null.$SLASH*/) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
 AbstractScanner$S.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
+  if (next == 93/*null.$RBRACKET*/) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendBeginGroup(91/*null.LBRACKET_TOKEN*/, "[");
     return next;
   }
 }
 AbstractScanner$S.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
@@ skipping 78 matching lines @@
 
     default:
 
       this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
 AbstractScanner$S.prototype.tokenizeEquals = function(next) {
   next = this.advance();
-  if ($notnull_bool(next == 61/*null.$EQ*/)) {
+  if (next == 61/*null.$EQ*/) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
 AbstractScanner$S.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
       this.appendStringToken(62/*null.GT_TOKEN*/, ">=");
       return this.advance();
 
     case 62/*null.$GT*/:
 
       next = this.advance();
       switch (next) {
         case 61/*null.$EQ*/:
 
           this.appendStringToken(62/*null.GT_TOKEN*/, ">>=");
           return this.advance();
 
         case 62/*null.$GT*/:
 
           {
             next = this.advance();
-            if ($notnull_bool(next === 61/*null.$EQ*/)) {
+            if (next === 61/*null.$EQ*/) {
               this.appendStringToken(62/*null.GT_TOKEN*/, ">>>=");
               return this.advance();
             }
             else {
               this.appendGtGtGt(62/*null.GT_TOKEN*/, ">>>");
               return next;
             }
           }
 
         default:
@@ skipping 25 matching lines @@
 
     default:
 
       this.appendBeginGroup(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 16 matching lines @@
       default:
 
         this.appendByteStringToken(105/*null.INT_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
-  if ($notnull_bool(x == 120/*null.$x*/ || x == 88/*null.$X*/)) {
+  if (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
 AbstractScanner$S.prototype.tokenizeHex = function(next) {
   var start = this.get$byteOffset();
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
@@ skipping 10 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!$notnull_bool(done))) {
+  while (!$notnull_bool(done)) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         break;
 
       case 101/*null.$e*/:
       case 69/*null.$E*/:
 
         next = this.tokenizeExponent(this.advance());
         done = true;
         continue LOOP;
 
       default:
 
         done = true;
         continue LOOP;
 
     }
     next = this.advance();
   }
-  if ($notnull_bool(next == 100/*null.$d*/ || next == 68/*null.$D*/)) {
+  if (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
     next = this.advance();
   }
   this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
 AbstractScanner$S.prototype.tokenizeExponent = function(next) {
-  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
+  if (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
     next = this.advance();
   }
   var hasDigits = false;
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!$notnull_bool(hasDigits))) {
+        if (!$notnull_bool(hasDigits)) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 12 matching lines @@
       return this.advance();
 
     default:
 
       this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineComment = function(next) {
-  while ($notnull_bool(true)) {
+  while (true) {
     next = this.advance();
     switch (next) {
       case -1:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
+        if (next == 47/*null.$SLASH*/) {
           return this.advance();
         }
-        else if ($notnull_bool(next == -1)) {
+        else if (next == -1) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeIdentifier = function(next) {
   var start = this.get$byteOffset();
   var state = null;
-  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+  if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while ($notnull_bool(true)) {
-    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
-      if ($notnull_bool(state != null)) {
+  while (true) {
+    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+      if (state != null) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
+    else if ((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
-    else if ($notnull_bool(next < 128)) {
+    else if (next < 128) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.utf8String(start, -1));
       }
       return next;
     }
     else {
       var nonAsciiStart = this.get$byteOffset();
       do {
         next = this.nextByte();
       }
-      while ($notnull_bool(next > 127))
+      while (next > 127)
       var string = $assert_String(this.utf8String(nonAsciiStart, -1).toString());
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.prototype.tokenizeRawString = function(next) {
   var start = this.get$byteOffset();
   next = this.advance();
-  if ($notnull_bool(next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/)) {
+  if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.get$charOffset()));
   }
 }
 AbstractScanner$S.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
-  if ($notnull_bool(q == next)) {
+  if (q == next) {
     next = this.advance();
-    if ($notnull_bool(q == next)) {
+    if (q == next) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
   if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 AbstractScanner$S.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
+    else if (next == 92/*null.$BACKSLASH*/) {
       next = this.advance();
-      if ($notnull_bool(next == -1)) {
+      if (next == -1) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner$S.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q1)) {
+  while (next != -1) {
+    if (next == q1) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
+    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
       $throw(new MalformedInputException(this.get$charOffset()));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.get$charOffset()));
 }
 AbstractScanner$S.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while ($notnull_bool(next != -1)) {
-    if ($notnull_bool(next == q)) {
+  while (next != -1) {
+    if (next == q) {
       next = this.advance();
-      if ($notnull_bool(next == q)) {
+      if (next == q) {
         next = this.advance();
-        if ($notnull_bool(next == q)) {
+        if (next == q) {
           this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for MalformedInputException **************
@@ skipping 12 matching lines @@
 $inherits(ScannerTask, CompilerTask);
 ScannerTask.prototype.get$name = function() {
   return 'Scanner';
 }
 ScannerTask.prototype.scan = function(script) {
   var $this = this; // closure support
   this.measure((function () {
     var $0;
     var elements = $this.scanElements(script.get$text());
     for (var link = elements;
-     $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
+     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
       $this.compiler.universe.define((($0 = link.get$head()) && $0.is$Element()));
     }
   })
   );
 }
 ScannerTask.prototype.scanElements = function(text) {
   var tokens = new StringScanner(text).tokenize();
   var listener = new ElementListener(this.compiler);
   var parser = new PartialParser(listener);
   parser.parseUnit(tokens);
@@ skipping 34 matching lines @@
   ;
   this.handleNoTypeVariables = (function (t) {
     return $this.listener.handleNoTypeVariables$1(t);
   })
   ;
 }
 PartialParser.prototype.next = function(token) {
   return this.checkEof(token.next);
 }
 PartialParser.prototype.checkEof = function(token) {
-  if ($notnull_bool(token.kind === 0/*null.EOF_TOKEN*/)) {
+  if (token.kind === 0/*null.EOF_TOKEN*/) {
     this.listener.unexpectedEof();
     $throw('Unexpected EOF');
   }
   return token;
 }
 PartialParser.prototype.parseUnit = function(token) {
-  while ($notnull_bool(token.kind !== 0/*null.EOF_TOKEN*/)) {
+  while (token.kind !== 0/*null.EOF_TOKEN*/) {
     var value = token.get$stringValue();
     switch (true) {
       case value === 'interface':
 
         token = this.parseInterface(token);
         break;
 
       case value === 'class':
 
         token = this.parseClass(token);
@@ skipping 33 matching lines @@
 PartialParser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
   token = this.parseFormalParameters(token);
   this.listener.endFunctionTypeAlias(token);
   return this.expect(';', token);
 }
 PartialParser.prototype.parseReturnTypeOpt = function(token) {
-  if ($notnull_bool(token.get$stringValue() === 'void')) {
+  if (token.get$stringValue() === 'void') {
     this.listener.handleVoidKeyword(token);
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
 PartialParser.prototype.parseFormalParameters = function(token) {
   var begin = token;
   this.listener.beginFormalParameters(begin);
@@ skipping 56 matching lines @@
   }
   return token;
 }
 PartialParser.prototype.parseFactoryClauseOpt = function(token) {
   if ($notnull_bool(this.optional('factory', token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 PartialParser.prototype.skipBlock = function(token) {
-  if ($notnull_bool(!$notnull_bool(this.optional('{', token)))) {
+  if (!$notnull_bool(this.optional('{', token))) {
     return this.listener.expectedBlock(token);
   }
   var beginGroupToken = (token && token.is$BeginGroupToken());
-  $assert($notnull_bool(beginGroupToken.endGroup == null || beginGroupToken.endGroup.kind === 125/*null.$RBRACE*/), "beginGroupToken.endGroup === null ||\n           beginGroupToken.endGroup.kind === $RBRACE", "parser.dart", 171, 12);
+  $assert(beginGroupToken.endGroup == null || beginGroupToken.endGroup.kind === 125/*null.$RBRACE*/, "beginGroupToken.endGroup === null ||\n           beginGroupToken.endGroup.kind === $RBRACE", "parser.dart", 171, 12);
   return beginGroupToken.endGroup;
 }
 PartialParser.prototype.skipArguments = function(token) {
   return token.endGroup;
 }
 PartialParser.prototype.parseClass = function(token) {
   var begin = token;
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
@@ skipping 20 matching lines @@
   this.listener.endClass(interfacesCount, begin, extendsKeyword, implementsKeyword, token);
   return token.next;
 }
 PartialParser.prototype.parseNativeClassClauseOpt = function(token) {
   if ($notnull_bool(this.optional('native', token))) {
     return this.parseString(this.next(token));
   }
   return token;
 }
 PartialParser.prototype.parseString = function(token) {
-  if ($notnull_bool(token.kind === 39/*null.STRING_TOKEN*/)) {
+  if (token.kind === 39/*null.STRING_TOKEN*/) {
     return this.next(token);
   }
   else {
     return this.listener.expected('string', token);
   }
 }
 PartialParser.prototype.parseIdentifier = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.handleIdentifier(token);
   }
   else {
     this.listener.expectedIdentifier(token);
   }
   return this.next(token);
 }
 PartialParser.prototype.expect = function(string, token) {
-  if ($notnull_bool(string !== token.get$stringValue())) {
-    if ($notnull_bool(string === '>')) {
-      if ($notnull_bool(token.get$stringValue() === '>>')) {
+  if (string !== token.get$stringValue()) {
+    if (string === '>') {
+      if (token.get$stringValue() === '>>') {
         var gt = new StringToken(62/*null.GT_TOKEN*/, '>', token.charOffset + 1);
         gt.next = token.next;
         return gt;
       }
-      else if ($notnull_bool(token.get$stringValue() === '>>>')) {
+      else if (token.get$stringValue() === '>>>') {
         var gtgt = new StringToken(1024/*null.UNKNOWN_TOKEN*/, '>>', token.charOffset + 1);
         gtgt.next = token.next;
         return gtgt;
       }
     }
     return this.listener.expected(string, token);
   }
   return token.next;
 }
 PartialParser.prototype.parseTypeVariable = function(token) {
@@ skipping 59 matching lines @@
   return token;
 }
 PartialParser.prototype.parseClassBody = function(token) {
   return this.skipBlock(token);
 }
 PartialParser.prototype.parseTopLevelMember = function(token) {
   var start = token;
   this.listener.beginTopLevelMember(token);
   var previous = token;
   LOOP:
-  while ($notnull_bool(token != null)) {
+  while (token != null) {
     var kind = token.kind;
     switch (true) {
       case kind === 123/*null.LBRACE_TOKEN*/:
       case kind === 59/*null.SEMICOLON_TOKEN*/:
       case kind === 40/*null.LPAREN_TOKEN*/:
       case kind === 61/*null.EQ_TOKEN*/:
 
         break LOOP;
 
       default:
 
         previous = token;
         token = this.next(token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
   var isField;
-  while ($notnull_bool(true)) {
+  while (true) {
     if ($notnull_bool(this.optional('(', token))) {
       isField = false;
       break;
     }
     else if ($notnull_bool(this.optional('=', token) || this.optional(';', token))) {
       isField = true;
       break;
     }
     else {
       token = this.listener.unexpected(token);
     }
   }
-  if ($notnull_bool(!$notnull_bool(isField))) {
+  if (!$notnull_bool(isField)) {
     token = this.next(this.skipArguments((token && token.is$BeginGroupToken())));
   }
-  while ($notnull_bool(token != null && token.kind !== 123/*null.LBRACE_TOKEN*/) && token.kind !== 59/*null.SEMICOLON_TOKEN*/) {
+  while (token != null && token.kind !== 123/*null.LBRACE_TOKEN*/ && token.kind !== 59/*null.SEMICOLON_TOKEN*/) {
     token = this.next(token);
   }
-  if ($notnull_bool(!$notnull_bool(this.optional(';', token)))) {
+  if (!$notnull_bool(this.optional(';', token))) {
     token = this.skipBlock(token);
   }
   if ($notnull_bool(isField)) {
     this.listener.endTopLevelField(start, token);
   }
   else {
     this.listener.endTopLevelMethod(start, token);
   }
   return token.next;
 }
 PartialParser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect('(', token);
-  while ($notnull_bool(token != null && token.kind !== 40/*null.LPAREN_TOKEN*/) && token.kind !== 41/*null.RPAREN_TOKEN*/) {
+  while (token != null && token.kind !== 40/*null.LPAREN_TOKEN*/ && token.kind !== 41/*null.RPAREN_TOKEN*/) {
     token = this.next(token);
   }
   token = this.expect(')', token);
   return this.expect(';', token);
 }
 PartialParser.prototype.beginTypeArguments$1 = function($0) {
   return this.beginTypeArguments.call$1($0);
 }
 ;
 PartialParser.prototype.beginTypeVariables$1 = function($0) {
@@ skipping 33 matching lines @@
 }
 Parser.prototype.parseFunctionBody = function(token) {
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endFunctionBody(0, null, token);
     return token.next;
   }
   var begin = token;
   var statementCount = 0;
   this.listener.beginFunctionBody(begin);
   token = this.checkEof(this.expect('{', token));
-  while ($notnull_bool(!$notnull_bool(this.optional('}', token)))) {
+  while (!$notnull_bool(this.optional('}', token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endFunctionBody(statementCount, begin, token);
   return this.expect('}', token);
 }
 Parser.prototype.parseStatement = function(token) {
   this.checkEof(token);
   var value = token.get$stringValue();
   switch (true) {
@@ skipping 44 matching lines @@
   }
   else {
     token = this.parseExpression(token);
     this.listener.endReturnStatement(true, begin, token);
   }
   return this.expectSemicolon(token);
 }
 Parser.prototype.parseExpressionStatementOrDeclaration = function(token) {
   $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 464, 12);
   var peek1 = this.next(token);
-  if ($notnull_bool(peek1.kind === 97/*null.IDENTIFIER_TOKEN*/)) {
+  if (peek1.kind === 97/*null.IDENTIFIER_TOKEN*/) {
     return this.parseLocalDeclaration(token, peek1);
   }
-  else if ($notnull_bool(peek1.kind === 60/*null.LT_TOKEN*/)) {
+  else if (peek1.kind === 60/*null.LT_TOKEN*/) {
     var beginGroupToken = (peek1 && peek1.is$BeginGroupToken());
     var gtToken = beginGroupToken.endGroup;
-    if ($notnull_bool(gtToken != null && gtToken.next.kind === 97/*null.IDENTIFIER_TOKEN*/)) {
+    if (gtToken != null && gtToken.next.kind === 97/*null.IDENTIFIER_TOKEN*/) {
       var identifier = gtToken.next;
       var afterId = identifier.next;
       var afterIdKind = afterId.kind;
-      if ($notnull_bool(afterIdKind === 61/*null.EQ_TOKEN*/ || afterIdKind === 59/*null.SEMICOLON_TOKEN*/)) {
+      if (afterIdKind === 61/*null.EQ_TOKEN*/ || afterIdKind === 59/*null.SEMICOLON_TOKEN*/) {
         return this.parseLocalDeclaration(token, identifier);
       }
-      else if ($notnull_bool(afterIdKind === 41/*null.RPAREN_TOKEN*/)) {
+      else if (afterIdKind === 41/*null.RPAREN_TOKEN*/) {
         var beginParen = (afterId && afterId.is$BeginGroupToken());
         var endParen = beginParen.endGroup;
         var afterParens = endParen.next;
         if ($notnull_bool(this.optional('{', afterParens) || this.optional('=>', afterParens))) {
           return this.parseLocalDeclaration(token, identifier);
         }
       }
     }
   }
   return this.parseExpressionStatement(token);
 }
 Parser.prototype.parseLocalDeclaration = function(token, peek1) {
   var peek2 = this.next(peek1);
-  if ($notnull_bool(peek2.get$stringValue() === '(')) {
+  if (peek2.get$stringValue() === '(') {
     return this.parseFunction(token);
   }
   else {
     return this.parseVariablesDeclaration(token);
   }
 }
 Parser.prototype.parseExpressionStatement = function(token) {
   this.listener.beginExpressionStatement(token);
   token = this.parseExpression(token);
   this.listener.endExpressionStatement(token);
@@ skipping 21 matching lines @@
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression(question, colon);
   }
   return token;
 }
 Parser.prototype.parseBinaryExpression = function(token, precedence) {
   $assert(precedence >= 4, "precedence >= 4", "parser.dart", 544, 12);
   token = this.parsePrimary(token);
   var tokenLevel = this.getPrecedence(token);
   for (var level = $assert_num(tokenLevel);
-   $notnull_bool(level >= precedence); --level) {
-    while ($notnull_bool(tokenLevel === level)) {
+   level >= precedence; --level) {
+    while (tokenLevel === level) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression(operator);
       tokenLevel = this.getPrecedence(token);
     }
   }
   return token;
 }
 Parser.prototype.getPrecedence = function(token) {
-  if ($notnull_bool(token == null)) return 0;
+  if (token == null) return 0;
   var value = token.get$stringValue();
-  if ($notnull_bool(value == null)) return 0;
+  if (value == null) return 0;
   switch (true) {
     case value === '(':
 
       return 0;
 
     case value === '+':
 
       return 12;
 
     case value === ')':
@@ skipping 216 matching lines @@
   return token.next;
 }
 Parser.prototype.parseSend = function(token) {
   this.listener.beginSend(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend(token);
   return token;
 }
 Parser.prototype.parseArgumentsOpt = function(token) {
-  if ($notnull_bool(!$notnull_bool(this.optional('(', token)))) {
+  if (!$notnull_bool(this.optional('(', token))) {
     this.listener.handleNoArguments(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
 Parser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
@@ skipping 75 matching lines @@
   token = this.expect(')', token);
   token = this.parseStatement(token);
   this.listener.endForStatement(forToken, token);
   return token;
 }
 Parser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock(begin);
   var statementCount = 0;
   token = this.expect('{', token);
-  while ($notnull_bool(!$notnull_bool(this.optional('}', token)))) {
+  while (!$notnull_bool(this.optional('}', token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endBlock(statementCount, begin, token);
   return this.expect('}', token);
 }
 Parser.prototype.parseThrowStatement = function(token) {
   var throwToken = token;
   this.listener.beginThrowStatement(throwToken);
   token = this.expect('throw', token);
@@ skipping 272 matching lines @@
   this.topLevelElements = const$16/*const EmptyLink()*/
   this.canceler = canceler;
   // Initializers done
 }
 $inherits(ElementListener, Listener);
 ElementListener.prototype.beginLibraryTag = function(token) {
   this.canceler.cancel("Cannot handle library tags");
 }
 ElementListener.prototype.endClass = function(interfacesCount, beginToken, extendsKeyword, implementsKeyword, endToken) {
   var $0;
-  for (; $notnull_bool(interfacesCount > 0); --interfacesCount) {
+  for (; interfacesCount > 0; --interfacesCount) {
     this.popNode();
   }
   var supertype = (($0 = this.popNode()) && $0.is$TypeAnnotation());
   var name = (($0 = this.popNode()) && $0.is$Identifier());
   this.pushElement(new PartialClassElement(name.get$source(), beginToken, endToken));
 }
 ElementListener.prototype.endInterface = function(token) {
   this.canceler.cancel("Cannot handle interfaces");
 }
 ElementListener.prototype.endFunctionTypeAlias = function(token) {
@@ skipping 12 matching lines @@
 }
 ElementListener.prototype.handleNoType = function(token) {
   this.pushNode(null);
 }
 ElementListener.prototype.endTypeVariable = function(token) {
   var $0;
   var bound = (($0 = this.popNode()) && $0.is$TypeAnnotation());
   var name = (($0 = this.popNode()) && $0.is$Identifier());
 }
 ElementListener.prototype.endTypeArguments = function(count, beginToken, endToken) {
-  for (; $notnull_bool(count > 0); --count) {
+  for (; count > 0; --count) {
     this.popNode();
   }
 }
 ElementListener.prototype.expected = function(string, token) {
   this.canceler.cancel(("Expected '" + string + "', but got '" + token + "' ") + ("@ " + token.charOffset + ""));
 }
 ElementListener.prototype.unexpectedEof = function() {
   this.canceler.cancel("Unexpected end of file");
 }
 ElementListener.prototype.expectedIdentifier = function(token) {
@@ skipping 82 matching lines @@
 NodeListener.prototype.handleLiteralDouble = function(token) {
   this.pushNode(new LiteralDouble(token, to$call$2(this.onError)));
 }
 NodeListener.prototype.handleLiteralBool = function(token) {
   this.pushNode(new LiteralBool(token, to$call$2(this.onError)));
 }
 NodeListener.prototype.handleLiteralString = function(token) {
   this.pushNode(new LiteralString(token));
 }
 NodeListener.prototype.handleBinaryExpression = function(token) {
-  var arguments = new NodeList(null, LinkFactory.Link$factory(this.popNode()), null, null);
+  var arguments = new NodeList(null, LinkFactory.createLink(this.popNode()), null, null);
   this.pushNode(new Send(this.popNode(), new Operator(token), arguments));
 }
 NodeListener.prototype.handleAssignmentExpression = function(token) {
   var arguments = new NodeList.singleton$ctor(this.popNode());
   var node = this.popNode();
-  if ($notnull_bool(!(node instanceof Send))) this.canceler.cancel(('not assignable: ' + node + ''));
+  if (!(node instanceof Send)) this.canceler.cancel(('not assignable: ' + node + ''));
   var send = (node && node.is$Send());
-  if ($notnull_bool(!$notnull_bool(send.get$isPropertyAccess()))) this.canceler.cancel(('not assignable: ' + node + ''));
-  if ($notnull_bool((send instanceof SendSet))) this.canceler.cancel('chained assignment');
+  if (!$notnull_bool(send.get$isPropertyAccess())) this.canceler.cancel(('not assignable: ' + node + ''));
+  if ((send instanceof SendSet)) this.canceler.cancel('chained assignment');
   this.pushNode(new SendSet(send.receiver, send.selector, token, arguments));
 }
 NodeListener.prototype.handleConditionalExpression = function(question, colon) {
   var elseExpression = this.popNode();
   var thenExpression = this.popNode();
   var condition = this.popNode();
   this.canceler.cancel('conditional expression not implemented yet');
 }
 NodeListener.prototype.endSend = function(token) {
   var $0;
@@ skipping 26 matching lines @@
 }
 NodeListener.prototype.endInitializer = function(assignmentOperator) {
   var $0;
   var initializer = (($0 = this.popNode()) && $0.is$Expression());
   var arguments = new NodeList.singleton$ctor(initializer);
   var name = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new SendSet(null, name, assignmentOperator, arguments));
 }
 NodeListener.prototype.endIfStatement = function(ifToken, elseToken) {
   var $0;
-  var elsePart = (($0 = $notnull_bool((elseToken == null)) ? null : this.popNode()) && $0.is$Statement());
+  var elsePart = (($0 = (elseToken == null) ? null : this.popNode()) && $0.is$Statement());
   var thenPart = (($0 = this.popNode()) && $0.is$Statement());
   var condition = (($0 = this.popNode()) && $0.is$NodeList());
   this.pushNode(new If(condition, thenPart, elsePart, ifToken, elseToken));
 }
 NodeListener.prototype.endForStatement = function(beginToken, endToken) {
   var $0;
   var body = (($0 = this.popNode()) && $0.is$Statement());
   var update = (($0 = this.popNode()) && $0.is$Expression());
   var condition = (($0 = this.popNode()) && $0.is$ExpressionStatement());
   var initializer = (($0 = this.popNode()) && $0.is$VariableDefinitions());
@@ skipping 10 matching lines @@
   var $0;
   var expression = (($0 = this.popNode()) && $0.is$Expression());
   this.pushNode(new Throw(expression, throwToken, endToken));
 }
 NodeListener.prototype.endRethrowStatement = function(throwToken, endToken) {
   this.pushNode(new Throw(null, throwToken, endToken));
 }
 NodeListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$16/*const EmptyLink()*/;
-  for (; $notnull_bool(count > 0); --count) {
+  for (; count > 0; --count) {
     nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
   }
-  var sourceDelimiter = (($0 = $notnull_bool((delimiter == null)) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
+  var sourceDelimiter = (($0 = (delimiter == null) ? null : new StringWrapper(delimiter)) && $0.is$SourceString());
   return new NodeList(beginToken, nodes, endToken, sourceDelimiter);
 }
 NodeListener.prototype.log = function(message) {
   this.logger.log(message);
 }
 // ********** Code for PartialFunctionElement **************
 function PartialFunctionElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   FunctionElement.call(this, name);
   // Initializers done
 }
 $inherits(PartialFunctionElement, FunctionElement);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
   var $this = this; // closure support
   var $0;
-  if ($notnull_bool(this.node != null)) return this.node;
+  if (this.node != null) return this.node;
   this.node = (($0 = parse(canceler, logger, (function (p) {
     return p.parseFunction($this.beginToken);
   })
   )) && $0.is$FunctionExpression());
   return this.node;
 }
 // ********** Code for PartialClassElement **************
 function PartialClassElement(name, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   ClassElement.call(this, name);
   // Initializers done
 }
 $inherits(PartialClassElement, ClassElement);
 PartialClassElement.prototype.parseNode = function(canceler, logger) {
   var $this = this; // closure support
   var $0;
-  if ($notnull_bool(this.node != null)) return this.node;
+  if (this.node != null) return this.node;
   this.node = (($0 = parse(canceler, logger, (function (p) {
     return p.parseClass($this.beginToken);
   })
   )) && $0.is$ClassNode());
   return this.node;
 }
 // ********** Code for StringScanner **************
 function StringScanner(string) {
   this.string = string;
   ArrayBasedScanner$SourceString.call(this);
   // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$SourceString);
 StringScanner.prototype.nextByte = function() {
   return this.charAt(++this.byteOffset);
 }
 StringScanner.prototype.peek = function() {
   return this.charAt(this.byteOffset + 1);
 }
 StringScanner.prototype.charAt = function(index) {
-  return $notnull_bool((this.string.length > $assert_num(index))) ? this.string.charCodeAt(index) : -1;
+  return (this.string.length > $assert_num(index)) ? this.string.charCodeAt(index) : -1;
 }
 StringScanner.prototype.asciiString = function(start) {
   return new SubstringWrapper(this.string, start, this.byteOffset);
 }
 StringScanner.prototype.utf8String = function(start, offset) {
   return new SubstringWrapper(this.string, start, this.byteOffset + offset + 1);
 }
 StringScanner.prototype.appendByteStringToken = function(kind, value) {
   this.tail.next = new StringToken.fromSource$ctor(kind, value, this.tokenStart);
   this.tail = this.tail.next;
 }
 // ********** Code for SubstringWrapper **************
 function SubstringWrapper(internalString, begin, end) {
   this.internalString = internalString;
   this.begin = begin;
   this.end = end;
   // Initializers done
 }
 SubstringWrapper.prototype.is$SourceString = function(){return this;};
 SubstringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 SubstringWrapper.prototype.$eq = function(other) {
-  return $notnull_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 SubstringWrapper.prototype.printOn = function(sb) {
   sb.add(this);
 }
 SubstringWrapper.prototype.toString = function() {
   return this.internalString.substring(this.begin, this.end);
 }
 SubstringWrapper.prototype.get$stringValue = function() {
   return null;
 }
@@ skipping 50 matching lines @@
 // ********** Code for StringWrapper **************
 function StringWrapper(internalString) {
   this.internalString = internalString;
   // Initializers done
 }
 StringWrapper.prototype.is$SourceString = function(){return this;};
 StringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 StringWrapper.prototype.$eq = function(other) {
-  return $notnull_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 StringWrapper.prototype.printOn = function(sb) {
   sb.add(this.internalString);
 }
 StringWrapper.prototype.toString = function() {
   return this.internalString;
 }
 StringWrapper.prototype.get$stringValue = function() {
   return this.internalString;
 }
 // ********** Code for BeginGroupToken **************
 function BeginGroupToken(kind, value, charOffset) {
   StringToken.call(this, kind, value, charOffset);
   // Initializers done
 }
 $inherits(BeginGroupToken, StringToken);
 BeginGroupToken.prototype.is$BeginGroupToken = function(){return this;};
 // ********** Code for Keyword **************
 function Keyword(syntax, isPseudo) {
   this.syntax = syntax;
   this.isPseudo = isPseudo;
   // Initializers done
 }
 Keyword.prototype.is$Keyword = function(){return this;};
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
-  if ($notnull_bool(Keyword._keywords == null)) {
+  if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
   var result = new LinkedHashMapImplementation$String$Keyword();
   for (var $i0 = const$234/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
     var keyword = $i0.next();
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
-  return $notnull_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
 Keyword.prototype.printOn = function(sb) {
   sb.add(this.syntax);
 }
 Keyword.prototype.toString = function() {
   return this.syntax;
 }
 Keyword.prototype.get$stringValue = function() {
   return this.syntax;
 }
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.prototype.is$KeywordState = function(){return this;};
 KeywordState.get$KEYWORD_STATE = function() {
-  if ($notnull_bool(KeywordState._KEYWORD_STATE == null)) {
+  if (KeywordState._KEYWORD_STATE == null) {
     var strings = new ListFactory$String(const$234/*Keyword.values*/.get$length());
     for (var i = 0;
-     $notnull_bool(i < const$234/*Keyword.values*/.get$length()); i++) {
+     i < const$234/*Keyword.values*/.get$length(); i++) {
       strings.$setindex(i, const$234/*Keyword.values*/[i].syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo(b);
     })
     );
     KeywordState._KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
   }
   return KeywordState._KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
   var result = new ListFactory$KeywordState(26);
   $assert(length != 0, "length != 0", "keyword.dart", 161, 12);
   var chunk = 0;
   var chunkStart = -1;
   for (var i = offset;
-   $notnull_bool(i < offset + length); i++) {
-    if ($notnull_bool(strings.$index(i).length > start)) {
+   i < offset + length; i++) {
+    if (strings.$index(i).length > start) {
       var c = strings.$index(i).charCodeAt(start);
-      if ($notnull_bool(chunk != c)) {
-        if ($notnull_bool(chunkStart != -1)) {
+      if (chunk != c) {
+        if (chunkStart != -1) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
-  if ($notnull_bool(chunkStart != -1)) {
+  if (chunkStart != -1) {
     result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart));
   }
   else {
     $assert(length == 1, "length == 1", "keyword.dart", 183, 14);
     return new LeafKeywordState($assert_String(strings.$index(offset)));
   }
   return new ArrayKeywordState(result);
 }
 // ********** Code for ArrayKeywordState **************
 function ArrayKeywordState(table) {
   this.table = table;
   // Initializers done
 }
 $inherits(ArrayKeywordState, KeywordState);
 ArrayKeywordState.prototype.isLeaf = function() {
   return false;
 }
 ArrayKeywordState.prototype.next = function(c) {
   var $0;
   return (($0 = this.table.$index(c - 97/*null.$a*/)) && $0.is$KeywordState());
 }
 ArrayKeywordState.prototype.get$keyword = function() {
   $throw("should not be called");
 }
 ArrayKeywordState.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   sb.add("[");
   var foo = this.table;
   for (var i = 0;
-   $notnull_bool(i < foo.length); i++) {
+   i < foo.length; i++) {
     if ($notnull_bool($ne(foo.$index(i), null))) {
       sb.add(("" + (i + 97/*null.$a*/) + ": " + foo.$index(i) + "; "));
     }
   }
   sb.add("]");
   return sb.toString();
 }
 // ********** Code for LeafKeywordState **************
 function LeafKeywordState(syntax) {
   var $0;
@@ skipping 99 matching lines @@
 }
 Send.prototype.get$isFunctionObjectInvocation = function() {
   return this.selector == null;
 }
 Send.prototype.getBeginToken = function() {
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
   var $0;
   var token;
-  if ($notnull_bool(this.argumentsNode != null)) token = this.argumentsNode.getEndToken();
-  if ($notnull_bool(token != null)) return token;
-  if ($notnull_bool(this.selector != null)) {
+  if (this.argumentsNode != null) token = this.argumentsNode.getEndToken();
+  if (token != null) return token;
+  if (this.selector != null) {
     return (($0 = this.selector.getEndToken()) && $0.is$Token());
   }
   return (($0 = this.receiver.getBeginToken()) && $0.is$Token());
 }
 // ********** Code for SendSet **************
 function SendSet(receiver, selector, assignmentOperator, argumentsNode) {
   this.assignmentOperator = assignmentOperator;
   Send.call(this, receiver, selector, argumentsNode);
   // Initializers done
 }
 $inherits(SendSet, Send);
 SendSet.prototype.is$SendSet = function(){return this;};
 SendSet.prototype.accept = function(visitor) {
   return visitor.visitSendSet(this);
 }
 // ********** Code for NodeList **************
 function NodeList(beginToken, nodes, endToken, delimiter) {
   this.beginToken = beginToken;
   this.nodes = nodes;
   this.endToken = endToken;
   this.delimiter = delimiter;
   // Initializers done
 }
 NodeList.singleton$ctor = function(node) {
-  NodeList.call(this, null, LinkFactory.Link$factory(node));
+  NodeList.call(this, null, LinkFactory.createLink(node));
   // Initializers done
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $inherits(NodeList, Node);
 NodeList.prototype.is$NodeList = function(){return this;};
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
-  if ($notnull_bool(this.beginToken != null)) return this.beginToken;
-  if ($notnull_bool(this.nodes != null)) {
+  if (this.beginToken != null) return this.beginToken;
+  if (this.nodes != null) {
     for (var link = this.nodes;
-     $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
-      if ($notnull_bool(link.get$head().getBeginToken() != null)) {
+     !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+      if (link.get$head().getBeginToken() != null) {
         return (($0 = link.get$head().getBeginToken()) && $0.is$Token());
       }
-      if ($notnull_bool(link.get$head().getEndToken() != null)) {
+      if (link.get$head().getEndToken() != null) {
         return (($0 = link.get$head().getEndToken()) && $0.is$Token());
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
   var $0;
-  if ($notnull_bool(this.endToken != null)) return this.endToken;
-  if ($notnull_bool(this.nodes != null)) {
+  if (this.endToken != null) return this.endToken;
+  if (this.nodes != null) {
     var link = this.nodes;
-    while ($notnull_bool(!$notnull_bool(link.get$tail().isEmpty()))) link = (($0 = link.get$tail()) && $0.is$Link$Node());
-    if ($notnull_bool(link.get$head().getEndToken() != null)) return (($0 = link.get$head().getEndToken()) && $0.is$Token());
-    if ($notnull_bool(link.get$head().getBeginToken() != null)) return (($0 = link.get$head().getBeginToken()) && $0.is$Token());
+    while (!$notnull_bool(link.get$tail().isEmpty())) link = (($0 = link.get$tail()) && $0.is$Link$Node());
+    if (link.get$head().getEndToken() != null) return (($0 = link.get$head().getEndToken()) && $0.is$Token());
+    if (link.get$head().getBeginToken() != null) return (($0 = link.get$head().getBeginToken()) && $0.is$Token());
   }
   return this.beginToken;
 }
 // ********** Code for Block **************
 function Block(statements) {
   this.statements = statements;
   // Initializers done
 }
 $inherits(Block, Statement);
 Block.prototype.accept = function(visitor) {
@@ skipping 18 matching lines @@
 If.prototype.get$hasElsePart = function() {
   return this.elsePart != null;
 }
 If.prototype.accept = function(visitor) {
   return visitor.visitIf(this);
 }
 If.prototype.getBeginToken = function() {
   return this.ifToken;
 }
 If.prototype.getEndToken = function() {
-  if ($notnull_bool(this.elsePart == null)) return this.thenPart.getEndToken();
+  if (this.elsePart == null) return this.thenPart.getEndToken();
   return this.elsePart.getEndToken();
 }
 // ********** Code for For **************
 function For(initializer, condition, update, body, forToken) {
   this.initializer = initializer;
   this.condition = condition;
   this.update = update;
   this.body = body;
   this.forToken = forToken;
   // Initializers done
@@ skipping 276 matching lines @@
 }
 Unparser.prototype.unparse = function(node) {
   this.sb = new StringBufferImpl("");
   this.visit(node);
   return this.sb.toString();
 }
 Unparser.prototype.add = function(string) {
   string.printOn(this.sb);
 }
 Unparser.prototype.visit = function(node) {
-  if ($notnull_bool(node != null)) {
+  if (node != null) {
     if ($notnull_bool(this.printDebugInfo)) this.sb.add(('[' + node.getObjectDescription() + ': '));
     node.accept(this);
     if ($notnull_bool(this.printDebugInfo)) this.sb.add(']');
   }
   else if ($notnull_bool(this.printDebugInfo)) {
     this.sb.add('[null]');
   }
 }
 Unparser.prototype.visitBlock = function(node) {
   this.visit(node.statements);
 }
 Unparser.prototype.visitExpressionStatement = function(node) {
   var $0;
   this.visit(node.expression);
   this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
 }
 Unparser.prototype.visitFor = function(node) {
   node.forToken.get$value().printOn(this.sb);
   this.sb.add('(');
   this.visit(node.initializer);
   this.visit(node.condition);
   this.visit(node.update);
   this.sb.add(')');
   this.visit(node.body);
 }
 Unparser.prototype.visitFunctionExpression = function(node) {
-  if ($notnull_bool(node.returnType != null)) {
+  if (node.returnType != null) {
     this.visit(node.returnType);
     this.sb.add(' ');
   }
   this.visit(node.name);
   this.visit(node.parameters);
   this.visit(node.body);
 }
 Unparser.prototype.visitIdentifier = function(node) {
   var $0;
   this.add((($0 = node.token.get$value()) && $0.is$SourceString()));
@@ skipping 19 matching lines @@
 Unparser.prototype.visitLiteralInt = function(node) {
   var $0;
   this.add((($0 = node.token.get$value()) && $0.is$SourceString()));
 }
 Unparser.prototype.visitLiteralString = function(node) {
   var $0;
   this.add((($0 = node.token.get$value()) && $0.is$SourceString()));
 }
 Unparser.prototype.visitNodeList = function(node) {
   var $0;
-  if ($notnull_bool(node.beginToken != null)) this.add((($0 = node.beginToken.get$value()) && $0.is$SourceString()));
-  if ($notnull_bool(node.nodes != null)) {
+  if (node.beginToken != null) this.add((($0 = node.beginToken.get$value()) && $0.is$SourceString()));
+  if (node.nodes != null) {
     node.nodes.printOn(this.sb, node.delimiter);
   }
-  if ($notnull_bool(node.endToken != null)) this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
+  if (node.endToken != null) this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
 }
 Unparser.prototype.visitOperator = function(node) {
   this.visitIdentifier(node);
 }
 Unparser.prototype.visitReturn = function(node) {
   var $0;
   this.add((($0 = node.beginToken.get$value()) && $0.is$SourceString()));
   if ($notnull_bool(node.get$hasExpression())) {
     this.sb.add(' ');
     this.visit(node.expression);
   }
   this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
 }
 Unparser.prototype.visitSend = function(node) {
-  if ($notnull_bool(node.receiver != null)) {
+  if (node.receiver != null) {
     this.visit(node.receiver);
-    if ($notnull_bool(!(node.selector instanceof Operator))) this.sb.add('.');
+    if (!(node.selector instanceof Operator)) this.sb.add('.');
   }
   this.visit(node.selector);
   this.visit(node.argumentsNode);
 }
 Unparser.prototype.visitSendSet = function(node) {
   var $0;
-  if ($notnull_bool(node.receiver != null)) {
+  if (node.receiver != null) {
     this.visit(node.receiver);
     this.sb.add('.');
   }
   this.visit(node.selector);
   this.add((($0 = node.assignmentOperator.get$value()) && $0.is$SourceString()));
   this.visit(node.argumentsNode);
 }
 Unparser.prototype.visitThrow = function(node) {
   node.throwToken.get$value().printOn(this.sb);
-  if ($notnull_bool(node.expression != null)) {
+  if (node.expression != null) {
     this.visit(node.expression);
   }
   node.endToken.get$value().printOn(this.sb);
 }
 Unparser.prototype.visitTypeAnnotation = function(node) {
   this.visit(node.typeName);
 }
 Unparser.prototype.visitVariableDefinitions = function(node) {
   var $0;
-  if ($notnull_bool(node.type != null)) {
+  if (node.type != null) {
     this.visit(node.type);
   }
   else {
     this.sb.add('var');
   }
   this.sb.add(' ');
   this.visit(node.definitions);
-  if ($notnull_bool(node.endToken != null)) this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
+  if (node.endToken != null) this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
 }
 // ********** Code for top level **************
 function firstBeginToken(first, second) {
   var $0;
-  return (($0 = $notnull_bool((first != null)) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
+  return (($0 = (first != null) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
 }
 //  ********** Library elements **************
 // ********** Code for ElementKind **************
 function ElementKind(id) {
   this.id = id;
   // Initializers done
 }
 // ********** Code for Element **************
 function Element(name, kind, enclosingElement) {
   this.name = name;
@@ skipping 30 matching lines @@
   return types.dynamicType;
 }
 // ********** Code for FunctionElement **************
 function FunctionElement(name) {
   Element.call(this, name, const$241, null);
   // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
-  if ($notnull_bool(this.type != null)) return (($0 = this.type) && $0.is$FunctionType());
+  if (this.type != null) return (($0 = this.type) && $0.is$FunctionType());
   var node = (($0 = this.parseNode(compiler, compiler)) && $0.is$FunctionExpression());
   var returnType = getType(node.returnType, types);
-  if ($notnull_bool(returnType == null)) compiler.cancel(('unknown type ' + returnType + ''));
+  if (returnType == null) compiler.cancel(('unknown type ' + returnType + ''));
   var parameterTypes = new LinkBuilderImplementation$Type();
   for (var link = node.parameters.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = link.get$tail()) {
+   !$notnull_bool(link.isEmpty()); link = link.get$tail()) {
     var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return (($0 = this.type) && $0.is$FunctionType());
 }
 // ********** Code for ClassElement **************
 function ClassElement(name) {
   Element.call(this, name, const$239, null);
   // Initializers done
 }
 $inherits(ClassElement, Element);
 ClassElement.prototype.computeType = function(compiler, types) {
   compiler.unimplemented('ClassElement.computeType');
 }
 // ********** Code for top level **************
 function getType(annotation, types) {
   var $0;
-  if ($notnull_bool(annotation == null || annotation.typeName == null)) {
+  if (annotation == null || annotation.typeName == null) {
     return (($0 = types.dynamicType) && $0.is$Type());
   }
   return (($0 = types.lookup(annotation.typeName.get$source())) && $0.is$Type());
 }
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
 function SsaBuilderTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaBuilderTask, CompilerTask);
 SsaBuilderTask.prototype.get$name = function() {
   return 'SSA builder';
 }
 SsaBuilderTask.prototype.build = function(tree, elements) {
   var $this = this; // closure support
   var $0;
   return (($0 = this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var graph = $this.compileMethod(function_.parameters, function_.body, elements);
     $assert(graph.isValid(), "graph.isValid()", "builder.dart", 14, 14);
-    if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
+    if (false/*null.GENERATE_SSA_TRACE*/) {
       var name = (($0 = function_.name) && $0.is$Identifier());
       HTracer.HTracer$singleton$factory().traceCompilation(name.get$source().toString());
       HTracer.HTracer$singleton$factory().traceGraph('builder', graph);
     }
     return graph;
   })
   )) && $0.is$HGraph());
 }
 SsaBuilderTask.prototype.compileMethod = function(parameters, body, elements) {
   var builder = new SsaBuilder(this.compiler, elements);
   var graph = builder.build(parameters, body);
   return graph;
 }
 // ********** Code for SsaBuilder **************
 function SsaBuilder(compiler, elements) {
   this.compiler = compiler;
   this.elements = elements;
   // Initializers done
 }
 SsaBuilder.prototype.build = function(parameters, body) {
   this.stack = new ListFactory$HInstruction();
   this.definitions = new HashMapImplementation$Element$HInstruction();
   this.graph = new HGraph();
   var block = this.graph.addNewBlock();
   this.open(this.graph.entry);
   this.visitParameters(parameters);
   this.close(new HGoto()).addSuccessor(block);
   this.open(block);
   body.accept(this);
-  if ($notnull_bool(!$notnull_bool(this.isAborted()))) this.close(new HGoto()).addSuccessor(this.graph.exit);
+  if (!$notnull_bool(this.isAborted())) this.close(new HGoto()).addSuccessor(this.graph.exit);
   this.graph.finalize();
   return this.graph;
 }
 SsaBuilder.prototype.open = function(block) {
   block.open();
   this.current = block;
 }
 SsaBuilder.prototype.close = function(end) {
   var result = this.current;
   this.current.close(end);
@@ skipping 12 matching lines @@
 }
 SsaBuilder.prototype.push = function(instruction) {
   this.add(instruction);
   this.stack.add(instruction);
 }
 SsaBuilder.prototype.pop = function() {
   var $0;
   return (($0 = this.stack.removeLast()) && $0.is$HInstruction());
 }
 SsaBuilder.prototype.visit = function(node) {
-  if ($notnull_bool(node != null)) node.accept(this);
+  if (node != null) node.accept(this);
 }
 SsaBuilder.prototype.visitParameters = function(parameters) {
   var $0;
   var parameterIndex = 0;
   for (var link = parameters.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var container = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     var identifierLink = container.definitions.nodes;
     $assert($notnull_bool(!$notnull_bool(identifierLink.isEmpty()) && identifierLink.get$tail().isEmpty()), "!identifierLink.isEmpty() && identifierLink.tail.isEmpty()", "builder.dart", 115, 14);
-    if ($notnull_bool(!(identifierLink.get$head() instanceof Identifier))) {
+    if (!(identifierLink.get$head() instanceof Identifier)) {
       this.compiler.unimplemented("SsaBuilder.visitParameters non-identifier");
     }
     var parameterId = (($0 = identifierLink.get$head()) && $0.is$Identifier());
     var element = (($0 = this.elements.$index(parameterId)) && $0.is$Element());
     var parameterInstruction = new HParameter(parameterIndex++);
     this.definitions.$setindex(element, parameterInstruction);
     this.add(parameterInstruction);
   }
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   var $0;
   for (var link = node.statements.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
     if ($notnull_bool(this.isAborted())) {
-      if ($notnull_bool(!$notnull_bool(this.stack.isEmpty()))) this.compiler.cancel('non-empty instruction stack');
+      if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
       return;
     }
   }
-  $assert($notnull_bool(!(this.current.last instanceof HGoto) && !(this.current.last instanceof HReturn)), "current.last is !HGoto && current.last is !HReturn", "builder.dart", 138, 12);
-  if ($notnull_bool(!$notnull_bool(this.stack.isEmpty()))) this.compiler.cancel('non-empty instruction stack');
+  $assert(!(this.current.last instanceof HGoto) && !(this.current.last instanceof HReturn), "current.last is !HGoto && current.last is !HReturn", "builder.dart", 138, 12);
+  if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitClassNode = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitClassNode");
 }
 SsaBuilder.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
   this.pop();
 }
 SsaBuilder.prototype.visitFor = function(node) {
   var $this = this; // closure support
-  $assert($notnull_bool(node.initializer != null && node.condition != null) && node.update != null && node.body != null, "node.initializer !== null && node.condition !== null &&\n           node.update !== null && node.body !== null", "builder.dart", 152, 12);
+  $assert(node.initializer != null && node.condition != null && node.update != null && node.body != null, "node.initializer !== null && node.condition !== null &&\n           node.update !== null && node.body !== null", "builder.dart", 152, 12);
   this.visit(node.initializer);
   $assert(!$notnull_bool(this.isAborted()), "!isAborted()", "builder.dart", 156, 12);
   var initializerBlock = this.close(new HGoto());
   var initializerDefinitions = HashMapImplementation.HashMapImplementation$from$factory(this.definitions);
   var conditionBlock = this.graph.addNewBlock();
   conditionBlock.isLoopHeader = true;
   initializerBlock.addSuccessor(conditionBlock);
   this.open(conditionBlock);
   initializerDefinitions.forEach((function (element, instruction) {
     var phi = new HPhi(instruction, instruction);
@@ skipping 20 matching lines @@
   var updateInstruction = this.pop();
   updateBlock = this.close(new HGoto());
   updateBlock.addSuccessor(conditionBlock);
   var currentInstruction = conditionBlock.first;
   initializerDefinitions.forEach((function (element, instruction) {
     var $0;
     var currentPhi = (currentInstruction && currentInstruction.is$HPhi());
     $assert(currentPhi.inputs.$index(0) === currentPhi.inputs.$index(1), "currentPhi.inputs[0] === currentPhi.inputs[1]", "builder.dart", 208, 14);
     $assert(currentPhi.inputs.$index(0) === instruction, "currentPhi.inputs[0] === instruction", "builder.dart", 209, 14);
     var afterBodyInstruction = (($0 = $this.definitions.$index(element)) && $0.is$HInstruction());
-    if ($notnull_bool(afterBodyInstruction !== currentPhi)) {
+    if (afterBodyInstruction !== currentPhi) {
       var oldInput = (($0 = currentPhi.inputs.$index(0)) && $0.is$HInstruction());
       for (var i = 0;
-       $notnull_bool(i < oldInput.get$usedBy().length); i++) {
-        if ($notnull_bool(oldInput.get$usedBy().$index(i) === currentPhi)) {
+       i < oldInput.get$usedBy().length; i++) {
+        if (oldInput.get$usedBy().$index(i) === currentPhi) {
           oldInput.get$usedBy().$setindex(i, oldInput.get$usedBy().$index(oldInput.get$usedBy().length - 1));
           oldInput.get$usedBy().length = oldInput.get$usedBy().length - 1;
           break;
         }
       }
       currentPhi.inputs.$setindex(1, afterBodyInstruction);
       afterBodyInstruction.get$usedBy().add(currentPhi);
     }
     else {
       conditionBlock.rewrite(currentPhi, (($0 = currentPhi.inputs.$index(0)) && $0.is$HInstruction()));
       conditionBlock.remove(currentPhi);
-      if ($notnull_bool($this.definitions.$index(element) === currentPhi)) {
+      if ($this.definitions.$index(element) === currentPhi) {
         $this.definitions.$setindex(element, currentPhi.inputs.$index(0));
       }
-      if ($notnull_bool(conditionDefinitions.$index(element) === currentPhi)) {
+      if (conditionDefinitions.$index(element) === currentPhi) {
         conditionDefinitions.$setindex(element, currentPhi.inputs.$index(0));
       }
     }
     currentInstruction = currentInstruction.next;
   })
   );
   var joinBlock = this.graph.addNewBlock();
   conditionExitBlock.addSuccessor(joinBlock);
   this.open(joinBlock);
   this.definitions = this.joinDefinitions(joinBlock, conditionDefinitions, this.definitions);
 }
 SsaBuilder.prototype.visitFunctionExpression = function(node) {
   this.compiler.unimplemented('SsaBuilder.visitFunctionExpression');
 }
 SsaBuilder.prototype.visitIdentifier = function(node) {
   var $0;
   var element = (($0 = this.elements.$index(node)) && $0.is$Element());
   this.compiler.ensure(element != null);
   var def = (($0 = this.definitions.$index(element)) && $0.is$HInstruction());
   $assert(def != null, "def !== null", "builder.dart", 253, 12);
   this.stack.add(def);
 }
 SsaBuilder.prototype.joinDefinitions = function(joinBlock, incoming1, incoming2) {
-  if ($notnull_bool(incoming1.get$length() > incoming2.get$length())) {
+  if (incoming1.get$length() > incoming2.get$length()) {
     return this.joinDefinitions(joinBlock, incoming2, incoming1);
   }
   var joinedDefinitions = new HashMapImplementation$Element$HInstruction();
   $assert(incoming1.get$length() <= incoming2.get$length(), "incoming1.length <= incoming2.length", "builder.dart", 272, 12);
   incoming1.forEach((function (element, instruction) {
     var $0;
     var other = (($0 = incoming2.$index(element)) && $0.is$HInstruction());
-    if ($notnull_bool(other == null)) return;
-    if ($notnull_bool(instruction === other)) {
+    if (other == null) return;
+    if (instruction === other) {
       joinedDefinitions.$setindex(element, instruction);
     }
     else {
       var phi = new HPhi((instruction && instruction.is$HInstruction()), other);
       joinBlock.add(phi);
       joinedDefinitions.$setindex(element, phi);
     }
   })
   );
   return joinedDefinitions;
@@ skipping 11 matching lines @@
   var thenDefinitions = this.definitions;
   this.definitions = conditionDefinitions;
   var elseBlock = null;
   if ($notnull_bool(hasElse)) {
     elseBlock = this.graph.addNewBlock();
     conditionBlock.addSuccessor(elseBlock);
     this.open(elseBlock);
     this.visit(node.elsePart);
     elseBlock = this.current;
   }
-  if ($notnull_bool(thenBlock == null && elseBlock == null) && hasElse) {
+  if ($notnull_bool(thenBlock == null && elseBlock == null && hasElse)) {
     this.current = null;
   }
   else {
     var joinBlock = this.graph.addNewBlock();
-    if ($notnull_bool(thenBlock != null)) this.goto(thenBlock, joinBlock);
-    if ($notnull_bool(elseBlock != null)) this.goto(elseBlock, joinBlock);
-    else if ($notnull_bool(!$notnull_bool(hasElse))) conditionBlock.addSuccessor(joinBlock);
+    if (thenBlock != null) this.goto(thenBlock, joinBlock);
+    if (elseBlock != null) this.goto(elseBlock, joinBlock);
+    else if (!$notnull_bool(hasElse)) conditionBlock.addSuccessor(joinBlock);
     this.open(joinBlock);
-    if ($notnull_bool(joinBlock.predecessors.length == 2)) {
+    if (joinBlock.predecessors.length == 2) {
       this.definitions = this.joinDefinitions(joinBlock, this.definitions, thenDefinitions);
     }
   }
 }
 SsaBuilder.prototype.unquote = function(literal) {
   var str = ('' + literal.get$value() + '');
   this.compiler.ensure(str[0] == '@');
   var quotes = 1;
   var quote = str[1];
-  while ($notnull_bool(str[quotes + 1] === quote)) quotes++;
+  while (str[quotes + 1] === quote) quotes++;
   return new StringWrapper(str.substring(quotes + 1, str.length - quotes));
 }
 SsaBuilder.prototype.visitSend = function(node) {
   var $0;
-  if ($notnull_bool((node.selector instanceof Operator))) {
+  if ((node.selector instanceof Operator)) {
     this.visit(node.receiver);
     this.visit(node.argumentsNode);
     var right = this.pop();
     var left = this.pop();
     var op = (($0 = node.selector) && $0.is$Operator());
     if ($notnull_bool($eq(const$266/*const SourceString("+")*/, op.get$source()))) {
       this.push(new HAdd([left, right]));
     }
     else if ($notnull_bool($eq(const$267/*const SourceString("-")*/, op.get$source()))) {
       this.push(new HSubtract([left, right]));
     }
     else if ($notnull_bool($eq(const$268/*const SourceString("*")*/, op.get$source()))) {
       this.push(new HMultiply([left, right]));
     }
     else if ($notnull_bool($eq(const$269/*const SourceString("/")*/, op.get$source()))) {
       this.push(new HDivide([left, right]));
     }
     else if ($notnull_bool($eq(const$270/*const SourceString("~/")*/, op.get$source()))) {
       this.push(new HTruncatingDivide([left, right]));
     }
     else if ($notnull_bool($eq(const$271/*const SourceString("==")*/, op.get$source()))) {
       this.push(new HEquals([left, right]));
     }
   }
   else if ($notnull_bool(node.get$isPropertyAccess())) {
-    if ($notnull_bool(node.receiver != null)) {
+    if (node.receiver != null) {
       this.compiler.unimplemented("SsaBuilder.visitSend with receiver");
     }
     var element = (($0 = this.elements.$index(node)) && $0.is$Element());
     this.stack.add(this.definitions.$index(element));
   }
   else {
     var link = node.get$arguments();
-    if ($notnull_bool(this.elements.$index(node).kind === const$244/*ElementKind.FOREIGN*/)) {
+    if (this.elements.$index(node).kind === const$244/*ElementKind.FOREIGN*/) {
       link = (($0 = link.get$tail()) && $0.is$Link$Node());
     }
     var arguments = [];
-    for (; $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+    for (; !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       this.visit((($0 = link.get$head()) && $0.is$Node()));
       arguments.add(this.pop());
     }
-    if ($notnull_bool(this.elements.$index(node).kind === const$244/*ElementKind.FOREIGN*/)) {
+    if (this.elements.$index(node).kind === const$244/*ElementKind.FOREIGN*/) {
       var literal = (($0 = node.get$arguments().get$head()) && $0.is$LiteralString());
       this.compiler.ensure((literal instanceof LiteralString));
       this.push(new HInvokeForeign(this.unquote(literal), arguments));
     }
     else {
       var selector = (($0 = node.selector) && $0.is$Identifier());
       this.push(new HInvoke(selector.get$source(), arguments));
     }
   }
 }
 SsaBuilder.prototype.visitSendSet = function(node) {
   this.stack.add(this.updateDefinition(node));
 }
 SsaBuilder.prototype.visitLiteralInt = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralDouble = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralBool = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralString = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 SsaBuilder.prototype.visitOperator = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitOperator");
 }
 SsaBuilder.prototype.visitReturn = function(node) {
-  if ($notnull_bool(node.expression == null)) {
+  if (node.expression == null) {
     this.compiler.unimplemented("SsaBuilder: return without expression");
   }
   this.visit(node.expression);
   var value = this.pop();
   this.close(new HReturn(value)).addSuccessor(this.graph.exit);
 }
 SsaBuilder.prototype.visitThrow = function(node) {
-  if ($notnull_bool(node.expression == null)) {
+  if (node.expression == null) {
     this.compiler.unimplemented("SsaBuilder: throw without expression");
   }
   this.visit(node.expression);
   this.close(new HThrow(this.pop()));
 }
 SsaBuilder.prototype.visitTypeAnnotation = function(node) {
 
 }
 SsaBuilder.prototype.updateDefinition = function(node) {
   var $0;
-  if ($notnull_bool(node.receiver != null)) {
+  if (node.receiver != null) {
     this.compiler.unimplemented("SsaBuilder: property access");
   }
   var link = node.get$arguments();
   $assert($notnull_bool(!$notnull_bool(link.isEmpty()) && link.get$tail().isEmpty()), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 456, 12);
   this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
   this.definitions.$setindex(this.elements.$index(node), value);
   return value;
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var definition = (($0 = link.get$head()) && $0.is$Node());
-    if ($notnull_bool((definition instanceof Identifier))) {
+    if ((definition instanceof Identifier)) {
       this.compiler.unimplemented("SsaBuilder.visitVariableDefinitions without initial value");
     }
     else {
       $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 472, 16);
       this.updateDefinition((definition && definition.is$SendSet()));
     }
   }
 }
 // ********** Code for SsaCodeGeneratorTask **************
 function SsaCodeGeneratorTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(tree, graph) {
   var $this = this; // closure support
   return $assert_String(this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var name = (($0 = function_.name) && $0.is$Identifier());
-    if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
+    if (false/*null.GENERATE_SSA_TRACE*/) {
       HTracer.HTracer$singleton$factory().traceGraph("codegen", graph);
     }
     var code = $this.generateMethod(name.get$source(), SsaCodeGeneratorTask.countParameters(function_), graph);
     return code;
   })
   ));
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, parameterCount, graph) {
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.compiler, buffer);
   graph.assignInstructionIds();
   codegen.visitGraph(graph);
   var parameters = new StringBufferImpl("");
   for (var i = 0;
-   $notnull_bool(i < parameterCount); i++) {
-    if ($notnull_bool(i != 0)) parameters.add(', ');
+   i < parameterCount; i++) {
+    if (i != 0) parameters.add(', ');
     parameters.add(SsaCodeGenerator.parameter(i));
   }
   return ('function ' + methodName + '(' + parameters + ') {\n' + buffer + '}\n');
 }
 SsaCodeGeneratorTask.countParameters = function(function_) {
   var $0;
   var result = 0;
   for (var link = function_.parameters.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     result++;
   }
   return result;
 }
 // ********** Code for SsaCodeGenerator **************
 function SsaCodeGenerator(compiler, buffer) {
   this.indent = 0
   this.compiler = compiler;
   this.buffer = buffer;
   // Initializers done
 }
 SsaCodeGenerator.prototype.visitGraph = function(graph) {
   this.currentGraph = graph;
   this.indent++;
   this.visitBasicBlock(graph.entry);
 }
 SsaCodeGenerator.temporary = function(instruction) {
   return ('t' + instruction.id + '');
 }
 SsaCodeGenerator.parameter = function(index) {
   return ('p' + index + '');
 }
 SsaCodeGenerator.prototype.invoke = function(selector, arguments) {
   var $0;
   this.buffer.add(('' + selector + '('));
   for (var i = 0;
-   $notnull_bool(i < arguments.length); i++) {
-    if ($notnull_bool(i != 0)) this.buffer.add(', ');
+   i < arguments.length; i++) {
+    if (i != 0) this.buffer.add(', ');
     this.use((($0 = arguments.$index(i)) && $0.is$HInstruction()));
   }
   this.buffer.add(")");
 }
 SsaCodeGenerator.prototype.define = function(instruction) {
   var $0;
   var usedBy = instruction.get$usedBy();
-  if ($notnull_bool(usedBy.length == 1 && (usedBy.$index(0) instanceof HPhi))) {
+  if (usedBy.length == 1 && (usedBy.$index(0) instanceof HPhi)) {
     this.buffer.add(('var ' + SsaCodeGenerator.temporary((($0 = usedBy.$index(0)) && $0.is$HInstruction())) + ' = '));
     this.visit(instruction);
   }
   else {
     var instructionId = SsaCodeGenerator.temporary(instruction);
     this.buffer.add(('var ' + instructionId + ' = '));
     this.visit(instruction);
     for (var i = 0;
-     $notnull_bool(i < usedBy.length); i++) {
-      if ($notnull_bool((usedBy.$index(i) instanceof HPhi))) {
+     i < usedBy.length; i++) {
+      if ((usedBy.$index(i) instanceof HPhi)) {
         this.buffer.add(';\n');
         this.addIndentation();
         this.buffer.add(('var ' + SsaCodeGenerator.temporary((($0 = usedBy.$index(i)) && $0.is$HInstruction())) + ' = ' + instructionId + ''));
       }
     }
   }
 }
 SsaCodeGenerator.prototype.use = function(argument) {
   if ($notnull_bool(argument.generateAtUseSite())) {
     this.visit(argument);
   }
   else {
     this.buffer.add(SsaCodeGenerator.temporary(argument));
   }
 }
 SsaCodeGenerator.prototype.visit = function(node) {
   return node.accept(this);
 }
 SsaCodeGenerator.prototype.visitAdd = function(node) {
   this.invoke(const$274/*const SourceString('\$add')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitBasicBlock = function(node) {
   if ($notnull_bool(node.isLoopHeader)) {
     this.buffer.add('while(true) {\n');
     this.indent++;
   }
   this.currentBlock = node;
   var instruction = node.first;
-  while ($notnull_bool(instruction != null)) {
-    if ($notnull_bool(!$notnull_bool(instruction.generateAtUseSite()))) {
+  while (instruction != null) {
+    if (!$notnull_bool(instruction.generateAtUseSite())) {
       this.addIndentation();
-      if ($notnull_bool(instruction.get$usedBy().isEmpty() || (instruction instanceof HPhi))) {
+      if (instruction.get$usedBy().isEmpty() || (instruction instanceof HPhi)) {
         this.visit(instruction);
       }
       else {
         this.define(instruction);
       }
       this.buffer.add(';\n');
     }
     instruction = instruction.next;
   }
 }
 SsaCodeGenerator.prototype.visitDivide = function(node) {
   this.invoke(const$276/*const SourceString('\$div')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitEquals = function(node) {
   this.invoke(const$277/*const SourceString('\$eq')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitExit = function(node) {
 
 }
 SsaCodeGenerator.prototype.visitGoto = function(node) {
   var $0;
   $assert(this.currentBlock.successors.length == 1, "currentBlock.successors.length == 1", "codegen.dart", 155, 12);
   var dominated = this.currentBlock.dominatedBlocks;
-  if ($notnull_bool(dominated.isEmpty())) return;
-  if ($notnull_bool(dominated.length > 2)) unreachable();
-  if ($notnull_bool(dominated.length == 2 && this.currentBlock !== this.currentGraph.entry)) {
+  if (dominated.isEmpty()) return;
+  if (dominated.length > 2) unreachable();
+  if (dominated.length == 2 && this.currentBlock !== this.currentGraph.entry) {
     unreachable();
   }
   $assert($eq(dominated.$index(0), this.currentBlock.successors.$index(0)), "dominated[0] == currentBlock.successors[0]", "codegen.dart", 167, 12);
   this.visitBasicBlock((($0 = dominated.$index(0)) && $0.is$HBasicBlock()));
 }
 SsaCodeGenerator.prototype.visitIf = function(node) {
   var $0;
   var ifBlock = this.currentBlock;
   this.buffer.add('if (');
   this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
@@ skipping 13 matching lines @@
     this.indent--;
     nextDominatedIndex = 2;
     this.addIndentation();
     this.buffer.add("}\n");
   }
   else {
     this.buffer.add("}\n");
     nextDominatedIndex = 1;
   }
   $assert(dominated.length <= nextDominatedIndex + 1, "dominated.length <= nextDominatedIndex + 1", "codegen.dart", 198, 12);
-  if ($notnull_bool(dominated.length == nextDominatedIndex + 1)) {
+  if (dominated.length == nextDominatedIndex + 1) {
     this.visitBasicBlock((($0 = dominated.$index(nextDominatedIndex)) && $0.is$HBasicBlock()));
   }
 }
 SsaCodeGenerator.prototype.visitInvoke = function(node) {
   this.compiler.worklist.add(node.selector);
   this.invoke(node.selector, node.inputs);
 }
 SsaCodeGenerator.prototype.visitInvokeForeign = function(node) {
   var $0;
   for (var i = 0;
-   $notnull_bool(i < node.inputs.length); i++) {
+   i < node.inputs.length; i++) {
     this.buffer.add(('var \$' + i + ' = '));
     this.use((($0 = node.inputs.$index(i)) && $0.is$HInstruction()));
     this.buffer.add(';\n');
   }
   this.addIndentation();
   this.buffer.add(node.selector);
 }
 SsaCodeGenerator.prototype.visitLiteral = function(node) {
   this.buffer.add(node.value);
 }
@@ skipping 17 matching lines @@
   this.invoke(const$278/*const SourceString('\$mul')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitParameter = function(node) {
   this.buffer.add(SsaCodeGenerator.parameter(node.parameterIndex));
 }
 SsaCodeGenerator.prototype.visitPhi = function(node) {
   var $0;
   var usedBy = node.get$usedBy();
   var firstPhi = true;
   for (var i = 0;
-   $notnull_bool(i < usedBy.length); i++) {
-    if ($notnull_bool((usedBy.$index(i) instanceof HPhi))) {
-      if ($notnull_bool(!$notnull_bool(firstPhi))) {
+   i < usedBy.length; i++) {
+    if ((usedBy.$index(i) instanceof HPhi)) {
+      if (!$notnull_bool(firstPhi)) {
         this.buffer.add(";\n");
         this.addIndentation();
       }
       this.buffer.add(("var " + SsaCodeGenerator.temporary((($0 = usedBy.$index(i)) && $0.is$HInstruction())) + " = " + SsaCodeGenerator.temporary(node) + ""));
       firstPhi = false;
     }
   }
 }
 SsaCodeGenerator.prototype.visitReturn = function(node) {
   var $0;
   this.buffer.add('return ');
   this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
 }
 SsaCodeGenerator.prototype.visitSubtract = function(node) {
   this.invoke(const$279/*const SourceString('\$sub')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitThrow = function(node) {
   var $0;
   this.buffer.add('throw ');
   this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
 }
 SsaCodeGenerator.prototype.visitTruncatingDivide = function(node) {
   this.invoke(const$280/*const SourceString('\$tdiv')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.addIndentation = function() {
   for (var i = 0;
-   $notnull_bool(i < this.indent); i++) {
+   i < this.indent; i++) {
     this.buffer.add('  ');
   }
 }
 // ********** Code for HGraphVisitor **************
 function HGraphVisitor() {
   // Initializers done
 }
 HGraphVisitor.prototype.visitDominatorTree = function(graph) {
   var $this = this; // closure support
   function visitBasicBlockAndSuccessors(block) {
     var $0;
     $this.visitBasicBlock(block);
     var dominated = block.dominatedBlocks;
     for (var i = 0;
-     $notnull_bool(i < dominated.length); i++) {
+     i < dominated.length; i++) {
       visitBasicBlockAndSuccessors((($0 = dominated.$index(i)) && $0.is$HBasicBlock()));
     }
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 HGraphVisitor.prototype.visitPostDominatorTree = function(graph) {
   var $this = this; // closure support
   function visitBasicBlockAndSuccessors(block) {
     var $0;
     var dominated = block.dominatedBlocks;
     for (var i = dominated.length - 1;
-     $notnull_bool(i >= 0); i--) {
+     i >= 0; i--) {
       visitBasicBlockAndSuccessors((($0 = dominated.$index(i)) && $0.is$HBasicBlock()));
     }
     $this.visitBasicBlock(block);
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 // ********** Code for HInstructionVisitor **************
 function HInstructionVisitor() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(HInstructionVisitor, HGraphVisitor);
 HInstructionVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
-  while ($notnull_bool(instruction != null)) {
+  while (instruction != null) {
     this.visitInstruction(instruction);
     instruction = instruction.next;
   }
 }
 // ********** Code for HGraph **************
 function HGraph() {
   this.blocks = new ListFactory$HBasicBlock();
   // Initializers done
   this.entry = this.addNewBlock();
   this.exit = new HBasicBlock();
@@ skipping 12 matching lines @@
 }
 HGraph.prototype.finalize = function() {
   this.addBlock(this.exit);
   this.exit.open();
   this.exit.close(new HExit());
   this.assignDominators();
 }
 HGraph.prototype.assignDominators = function() {
   var $0;
   for (var i = 0, length = this.blocks.length;
-   $notnull_bool(i < length); i++) {
+   i < length; i++) {
     var block = (($0 = this.blocks.$index(i)) && $0.is$HBasicBlock());
     var predecessors = block.predecessors;
     if ($notnull_bool(block.isLoopHeader)) {
       $assert(predecessors.length >= 2, "predecessors.length >= 2", "nodes.dart", 109, 16);
       block.assignCommonDominator((($0 = predecessors.$index(0)) && $0.is$HBasicBlock()));
     }
     else {
       for (var j = predecessors.length - 1;
-       $notnull_bool(j >= 0); j--) {
+       j >= 0; j--) {
         block.assignCommonDominator((($0 = predecessors.$index(j)) && $0.is$HBasicBlock()));
       }
     }
   }
 }
 HGraph.prototype.assignInstructionIds = function() {
   function handleDominatorTree(root, id) {
     var $0;
     id = root.assignInstructionIds(id);
     var dominatedBlocks = root.dominatedBlocks;
     for (var i = 0, length = dominatedBlocks.length;
-     $notnull_bool(i < length); i++) {
+     i < length; i++) {
       id = handleDominatorTree((($0 = dominatedBlocks.$index(i)) && $0.is$HBasicBlock()), id);
     }
     return id;
   }
   handleDominatorTree(this.entry, 0);
 }
 HGraph.prototype.isValid = function() {
   var validator = new HValidator();
   validator.visitGraph(this);
   return validator.isValid;
 }
 // ********** Code for HBaseVisitor **************
 function HBaseVisitor() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(HBaseVisitor, HGraphVisitor);
 HBaseVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
-  while ($notnull_bool(instruction != null)) {
+  while (instruction != null) {
     instruction.accept(this);
     instruction = instruction.next;
   }
 }
 HBaseVisitor.prototype.visitInstruction = function(HInstruction) {
 
 }
 HBaseVisitor.prototype.visitArithmetic = function(node) {
   return this.visitInvoke(node);
 }
@@ skipping 91 matching lines @@
   $assert(this.isNew(), "isNew()", "nodes.dart", 205, 12);
   this.status = 1/*HBasicBlock.STATUS_OPEN*/;
 }
 HBasicBlock.prototype.close = function(end) {
   $assert(this.isOpen(), "isOpen()", "nodes.dart", 210, 12);
   this.addAfter(this.last, end);
   this.status = 2/*HBasicBlock.STATUS_CLOSED*/;
 }
 HBasicBlock.prototype.assignInstructionIds = function(id) {
   var instruction = this.first;
-  while ($notnull_bool(instruction != null)) {
+  while (instruction != null) {
     instruction.id = id++;
     instruction = instruction.next;
   }
   return id;
 }
 HBasicBlock.prototype.accept = function(visitor) {
   return visitor.visitBasicBlock(this);
 }
 HBasicBlock.prototype.add = function(instruction) {
   $assert(!(instruction instanceof HControlFlow), "instruction is !HControlFlow", "nodes.dart", 238, 12);
   this.addAfter(this.last, instruction);
 }
 HBasicBlock.prototype.addSuccessor = function(block) {
   $assert($notnull_bool(this.isClosed() && ($notnull_bool(block.isNew() || block.id < this.id))), "isClosed() && (block.isNew() || block.id < id)", "nodes.dart", 244, 12);
-  if ($notnull_bool(this.successors.isEmpty())) {
+  if (this.successors.isEmpty()) {
     this.successors = [block];
   }
   else {
     this.successors.add(block);
   }
   block.predecessors.add(this);
 }
 HBasicBlock.prototype.addAfter = function(cursor, instruction) {
   $assert($notnull_bool(this.isOpen() || this.isClosed()), "isOpen() || isClosed()", "nodes.dart", 254, 12);
-  if ($notnull_bool(cursor == null)) {
+  if (cursor == null) {
     this.first = this.last = instruction;
   }
-  else if ($notnull_bool(cursor === this.last)) {
+  else if (cursor === this.last) {
     this.last.next = instruction;
     instruction.previous = this.last;
     this.last = instruction;
   }
   else {
     instruction.previous = cursor;
     instruction.next = cursor.next;
     cursor.next.previous = instruction;
     cursor.next = instruction;
   }
   instruction.notifyAddedToBlock();
 }
 HBasicBlock.prototype.remove = function(instruction) {
   $assert($notnull_bool(this.isOpen() || this.isClosed()), "isOpen() || isClosed()", "nodes.dart", 271, 12);
   $assert(instruction.isInBasicBlock(), "instruction.isInBasicBlock()", "nodes.dart", 272, 12);
   $assert(instruction.get$usedBy().isEmpty(), "instruction.usedBy.isEmpty()", "nodes.dart", 273, 12);
-  if ($notnull_bool(instruction.previous == null)) {
+  if (instruction.previous == null) {
     this.first = instruction.next;
   }
   else {
     instruction.previous.next = instruction.next;
   }
-  if ($notnull_bool(instruction.next == null)) {
+  if (instruction.next == null) {
     this.last = instruction.previous;
   }
   else {
     instruction.next.previous = instruction.previous;
   }
   instruction.notifyRemovedFromBlock();
 }
 HBasicBlock.prototype.rewrite = function(from, to) {
   var $list = from.get$usedBy();
   for (var $i = 0;$i < $list.length; $i++) {
     var use = $list.$index($i);
     HBasicBlock.rewriteInput(use, from, to);
   }
   to.get$usedBy().addAll(from.get$usedBy());
   from._usedBy = [];
 }
 HBasicBlock.rewriteInput = function(instruction, from, to) {
   var inputs = instruction.inputs;
   for (var i = 0;
-   $notnull_bool(i < inputs.length); i++) {
-    if ($notnull_bool(inputs.$index(i) === from)) inputs.$setindex(i, to);
+   i < inputs.length; i++) {
+    if (inputs.$index(i) === from) inputs.$setindex(i, to);
   }
 }
 HBasicBlock.prototype.isExitBlock = function() {
-  return $notnull_bool(this.first === this.last && (this.first instanceof HExit));
+  return this.first === this.last && (this.first instanceof HExit);
 }
 HBasicBlock.prototype.addDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 313, 12);
-  $assert($notnull_bool(this.id != null && block.id != null), "id !== null && block.id !== null", "nodes.dart", 314, 12);
+  $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 314, 12);
   $assert(this.dominatedBlocks.indexOf(block) < 0, "dominatedBlocks.indexOf(block) < 0", "nodes.dart", 315, 12);
   var index = this.dominatedBlocks.length;
-  while ($notnull_bool(index > 0 && this.dominatedBlocks.$index(index - 1).id > block.id)) {
+  while (index > 0 && this.dominatedBlocks.$index(index - 1).id > block.id) {
     index--;
   }
-  if ($notnull_bool(index == this.dominatedBlocks.length)) {
+  if (index == this.dominatedBlocks.length) {
     this.dominatedBlocks.add(block);
   }
   else {
     this.dominatedBlocks.insertRange(index, 1, block);
   }
   $assert(block.dominator == null, "block.dominator === null", "nodes.dart", 328, 12);
   block.dominator = this;
 }
 HBasicBlock.prototype.removeDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 333, 12);
-  $assert($notnull_bool(this.id != null && block.id != null), "id !== null && block.id !== null", "nodes.dart", 334, 12);
+  $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 334, 12);
   var index = this.dominatedBlocks.indexOf(block);
   $assert(index >= 0, "index >= 0", "nodes.dart", 336, 12);
-  if ($notnull_bool(index == this.dominatedBlocks.length - 1)) {
+  if (index == this.dominatedBlocks.length - 1) {
     this.dominatedBlocks.removeLast();
   }
   else {
     this.dominatedBlocks.removeRange(index, 1);
   }
   $assert(block.dominator === this, "block.dominator === this", "nodes.dart", 342, 12);
   block.dominator = null;
 }
 HBasicBlock.prototype.assignCommonDominator = function(predecessor) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 347, 12);
-  if ($notnull_bool(this.dominator == null)) {
+  if (this.dominator == null) {
     predecessor.addDominatedBlock(this);
   }
-  else if ($notnull_bool(predecessor.dominator != null)) {
+  else if (predecessor.dominator != null) {
     var first = this.dominator;
     var second = predecessor;
-    while ($notnull_bool(first !== second)) {
-      if ($notnull_bool(first.id > second.id)) {
+    while (first !== second) {
+      if (first.id > second.id) {
         first = first.dominator;
       }
       else {
         second = second.dominator;
       }
-      $assert($notnull_bool(first != null && second != null), "first !== null && second !== null", "nodes.dart", 364, 16);
+      $assert(first != null && second != null, "first !== null && second !== null", "nodes.dart", 364, 16);
     }
-    if ($notnull_bool(this.dominator !== first)) {
+    if (this.dominator !== first) {
       this.dominator.removeDominatedBlock(this);
       first.addDominatedBlock(this);
     }
   }
 }
 // ********** Code for HInstruction **************
 function HInstruction(inputs) {
   this._usedBy = null
   this.previous = null
   this.next = null
@@ skipping 27 matching lines @@
 HInstruction.prototype.generateAtUseSite = function() {
   return this.getFlag(2/*HInstruction.FLAG_GENERATE_AT_USE_SITE*/);
 }
 HInstruction.prototype.setGenerateAtUseSite = function() {
   this.setFlag(2/*HInstruction.FLAG_GENERATE_AT_USE_SITE*/);
 }
 HInstruction.prototype.setUseGvn = function() {
   this.setFlag(3/*HInstruction.FLAG_USE_GVN*/);
 }
 HInstruction.prototype.get$usedBy = function() {
-  if ($notnull_bool(this._usedBy == null)) return const$15/*const []*/;
+  if (this._usedBy == null) return const$15/*const []*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
   $assert(!$notnull_bool(this.isInBasicBlock()), "!isInBasicBlock()", "nodes.dart", 472, 12);
   this._usedBy = [];
   for (var i = 0;
-   $notnull_bool(i < this.inputs.length); i++) {
+   i < this.inputs.length; i++) {
     $assert(this.inputs.$index(i).isInBasicBlock(), "inputs[i].isInBasicBlock()", "nodes.dart", 476, 14);
     this.inputs.$index(i).get$usedBy().add(this);
   }
   $assert(this.isValid(), "isValid()", "nodes.dart", 479, 12);
 }
 HInstruction.prototype.notifyRemovedFromBlock = function() {
   $assert(this.isInBasicBlock(), "isInBasicBlock()", "nodes.dart", 483, 12);
   $assert(this.get$usedBy().isEmpty(), "usedBy.isEmpty()", "nodes.dart", 484, 12);
   for (var i = 0;
-   $notnull_bool(i < this.inputs.length); i++) {
+   i < this.inputs.length; i++) {
     var inputUsedBy = this.inputs.$index(i).get$usedBy();
     for (var j = 0;
-     $notnull_bool(j < inputUsedBy.length); j++) {
-      if ($notnull_bool(inputUsedBy.$index(j) === this)) {
+     j < inputUsedBy.length; j++) {
+      if (inputUsedBy.$index(j) === this) {
         inputUsedBy.$setindex(j, inputUsedBy.$index(inputUsedBy.length - 1));
         inputUsedBy.removeLast();
         break;
       }
     }
   }
   this._usedBy = null;
   $assert(this.isValid(), "isValid()", "nodes.dart", 498, 12);
 }
 HInstruction.prototype.isLiteralNumber = function() {
@@ skipping 41 matching lines @@
 HInvokeForeign.prototype.accept = function(visitor) {
   return visitor.visitInvokeForeign(this);
 }
 // ********** Code for HArithmetic **************
 function HArithmetic(selector, inputs) {
   HInvoke.call(this, selector, inputs);
   // Initializers done
 }
 $inherits(HArithmetic, HInvoke);
 HArithmetic.prototype.prepareGvn = function() {
-  if ($notnull_bool(!(this.inputs.$index(0) instanceof HLiteral))) return;
+  if (!(this.inputs.$index(0) instanceof HLiteral)) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 // ********** Code for HAdd **************
 function HAdd(inputs) {
   HArithmetic.call(this, const$247/*const SourceString('+')*/, inputs);
   // Initializers done
 }
 $inherits(HAdd, HArithmetic);
 HAdd.prototype.prepareGvn = function() {
-  if ($notnull_bool(!$notnull_bool(this.inputs.$index(0).isLiteralNumber()))) return;
+  if (!$notnull_bool(this.inputs.$index(0).isLiteralNumber())) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 HAdd.prototype.accept = function(visitor) {
   return visitor.visitAdd(this);
 }
 HAdd.prototype.evaluate = function(a, b) {
   return a + b;
 }
 // ********** Code for HDivide **************
@@ skipping 44 matching lines @@
 HTruncatingDivide.prototype.evaluate = function(a, b) {
   return $truncdiv(a, b);
 }
 // ********** Code for HEquals **************
 function HEquals(inputs) {
   HInvoke.call(this, const$253/*const SourceString('==')*/, inputs);
   // Initializers done
 }
 $inherits(HEquals, HInvoke);
 HEquals.prototype.prepareGvn = function() {
-  if ($notnull_bool(!(this.inputs.$index(0) instanceof HLiteral))) return;
+  if (!(this.inputs.$index(0) instanceof HLiteral)) return;
   this.clearAllSideEffects();
   this.setUseGvn();
 }
 HEquals.prototype.accept = function(visitor) {
   return visitor.visitEquals(this);
 }
 // ********** Code for HExit **************
 function HExit() {
   HControlFlow.call(this, const$15/*const []*/);
   // Initializers done
@@ skipping 142 matching lines @@
 function SsaConstantFolder() {
   HBaseVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaConstantFolder, HBaseVisitor);
 SsaConstantFolder.prototype.visitGraph = function(graph) {
   this.visitDominatorTree(graph);
 }
 SsaConstantFolder.prototype.visitBasicBlock = function(block) {
   var instruction = block.first;
-  while ($notnull_bool(instruction != null)) {
+  while (instruction != null) {
     var replacement = instruction.accept(this);
-    if ($notnull_bool(replacement !== instruction)) {
+    if (replacement !== instruction) {
       block.addAfter(instruction, (replacement && replacement.is$HInstruction()));
       block.rewrite(instruction, (replacement && replacement.is$HInstruction()));
       block.remove(instruction);
     }
     instruction = instruction.next;
   }
 }
 SsaConstantFolder.prototype.visitInstruction = function(node) {
   return node;
 }
 SsaConstantFolder.prototype.visitEquals = function(node) {
   var $0;
   var inputs = node.inputs;
-  if ($notnull_bool((inputs.$index(0) instanceof HLiteral) && (inputs.$index(1) instanceof HLiteral))) {
+  if ((inputs.$index(0) instanceof HLiteral) && (inputs.$index(1) instanceof HLiteral)) {
     var op1 = (($0 = inputs.$index(0)) && $0.is$HLiteral());
     var op2 = (($0 = inputs.$index(1)) && $0.is$HLiteral());
     return new HLiteral($eq(op1.value, op2.value));
   }
   return node;
 }
 SsaConstantFolder.prototype.visitArithmetic = function(node) {
   var $0;
   var inputs = node.inputs;
   $assert(inputs.length == 2, "inputs.length == 2", "optimize.dart", 57, 12);
@@ skipping 20 matching lines @@
   }
   return this.visitArithmetic(node);
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
-  return $notnull_bool(!$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty());
+  return !$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty();
 }
 SsaDeadCodeEliminator.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaDeadCodeEliminator.prototype.visitBasicBlock = function(block) {
   var instruction = block.last;
-  while ($notnull_bool(instruction != null)) {
+  while (instruction != null) {
     var previous = instruction.previous;
     if ($notnull_bool(SsaDeadCodeEliminator.isDeadCode(instruction))) block.remove(instruction);
     instruction = (previous && previous.is$HInstruction());
   }
 }
 // ********** Code for SsaInstructionMerger **************
 function SsaInstructionMerger() {
   HInstructionVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaInstructionMerger, HInstructionVisitor);
 SsaInstructionMerger.prototype.visitGraph = function(graph) {
   this.visitDominatorTree(graph);
 }
 SsaInstructionMerger.prototype.visitInstruction = function(node) {
   var inputs = node.inputs;
   var previousUnused = node.previous;
   for (var i = inputs.length - 1;
-   $notnull_bool(i >= 0); i--) {
-    if ($notnull_bool(previousUnused == null)) return;
-    if ($notnull_bool((previousUnused instanceof HPhi))) return;
-    if ($notnull_bool(inputs.$index(i).get$usedBy().length != 1)) return;
-    if ($notnull_bool(inputs.$index(i) !== previousUnused)) return;
+   i >= 0; i--) {
+    if (previousUnused == null) return;
+    if ((previousUnused instanceof HPhi)) return;
+    if (inputs.$index(i).get$usedBy().length != 1) return;
+    if (inputs.$index(i) !== previousUnused) return;
     inputs.$index(i).setGenerateAtUseSite();
     previousUnused = previousUnused.previous;
   }
 }
 // ********** Code for HTracer **************
 function HTracer() {}
 HTracer._internal$ctor = function() {
   this.indent = 0
   this.output = new StringBufferImpl("");
   // Initializers done
 }
 HTracer._internal$ctor.prototype = HTracer.prototype;
 $inherits(HTracer, HGraphVisitor);
 HTracer.HTracer$singleton$factory = function() {
-  if ($notnull_bool(HTracer._singleton == null)) HTracer._singleton = new HTracer._internal$ctor();
+  if (HTracer._singleton == null) HTracer._singleton = new HTracer._internal$ctor();
   return HTracer._singleton;
 }
 HTracer.prototype.traceCompilation = function(methodName) {
   var $this = this; // closure support
   this.tag("compilation", (function () {
     $this.printProperty("name", methodName);
     $this.printProperty("method", methodName);
     $this.printProperty("date", new DateImplementation.now$ctor().value);
   })
   );
 }
 HTracer.prototype.traceGraph = function(name, graph) {
   var $this = this; // closure support
   graph.assignInstructionIds();
   this.tag("cfg", (function () {
     $this.printProperty("name", name);
     $this.visitDominatorTree(graph);
   })
   );
 }
 HTracer.prototype.addPredecessors = function(block) {
-  if ($notnull_bool(block.predecessors.isEmpty())) {
+  if (block.predecessors.isEmpty()) {
     this.printEmptyProperty("predecessors");
   }
   else {
     this.addIndent();
     this.add("predecessors");
     var $list = block.predecessors;
     for (var $i = 0;$i < $list.length; $i++) {
       var predecessor = $list.$index($i);
       this.add((' "B' + predecessor.id + '"'));
     }
     this.add("\n");
   }
 }
 HTracer.prototype.addSuccessors = function(block) {
-  if ($notnull_bool(block.successors.isEmpty())) {
+  if (block.successors.isEmpty()) {
     this.printEmptyProperty("successors");
   }
   else {
     this.addIndent();
     this.add("successors");
     var $list = block.successors;
     for (var $i = 0;$i < $list.length; $i++) {
       var successor = $list.$index($i);
       this.add((' "B' + successor.id + '"'));
     }
     this.add("\n");
   }
 }
 HTracer.prototype.addInstructions = function(block) {
   var stringifier = new HInstructionStringifier(block);
   for (var instruction = block.first;
-   $notnull_bool(instruction != null); instruction = instruction.next) {
+   instruction != null; instruction = instruction.next) {
     var bci = 0;
     var uses = instruction.get$usedBy().length;
     this.addIndent();
     var temporaryId = stringifier.temporaryId(instruction);
     var instructionString = $assert_String(stringifier.visit(instruction));
     this.add(("" + bci + " " + uses + " " + temporaryId + " " + instructionString + " <|@\n"));
   }
 }
 HTracer.prototype.visitBasicBlock = function(block) {
   var $this = this; // closure support
   $assert(block.id != null, "block.id !== null", "tracer.dart", 75, 12);
   this.tag("block", (function () {
     $this.printProperty("name", ("B" + block.id + ""));
     $this.printProperty("from_bci", -1);
     $this.printProperty("to_bci", -1);
     $this.addPredecessors(block);
     $this.addSuccessors(block);
     $this.printEmptyProperty("xhandlers");
     $this.printEmptyProperty("flags");
-    if ($notnull_bool(block.dominator != null)) {
+    if (block.dominator != null) {
       $this.printProperty("dominator", ("B" + block.dominator.id + ""));
     }
     $this.tag("states", (function () {
       $this.tag("locals", (function () {
         $this.printProperty("size", 0);
         $this.printProperty("method", "None");
       })
       );
     })
     );
@@ skipping 13 matching lines @@
 }
 HTracer.prototype.print = function(string) {
   this.addIndent();
   this.add(string);
   this.add("\n");
 }
 HTracer.prototype.printEmptyProperty = function(propertyName) {
   this.print(propertyName);
 }
 HTracer.prototype.printProperty = function(propertyName, value) {
-  if ($notnull_bool((typeof(value) == 'number'))) {
+  if ((typeof(value) == 'number')) {
     this.print(("" + propertyName + " " + value + ""));
   }
   else {
     this.print(('' + propertyName + ' "' + value + '"'));
   }
 }
 HTracer.prototype.add = function(string) {
   this.output.add(string);
 }
 HTracer.prototype.addIndent = function() {
   for (var i = 0;
-   $notnull_bool(i < this.indent); i++) {
+   i < this.indent; i++) {
     this.add("  ");
   }
 }
 HTracer.prototype.toString = function() {
   return this.output.toString();
 }
 // ********** Code for HInstructionStringifier **************
 function HInstructionStringifier(currentBlock) {
   this.currentBlock = currentBlock;
   // Initializers done
@@ skipping 28 matching lines @@
   var $0;
   var thenBlock = (($0 = this.currentBlock.successors.$index(0)) && $0.is$HBasicBlock());
   var elseBlock = (($0 = this.currentBlock.successors.$index(1)) && $0.is$HBasicBlock());
   var conditionId = this.temporaryId((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
   return ("If (" + conditionId + "): (B" + thenBlock.id + ") else (B" + elseBlock.id + ")");
 }
 HInstructionStringifier.prototype.visitGenericInvoke = function(invokeType, invoke) {
   var $0;
   var arguments = new StringBufferImpl("");
   for (var i = 0;
-   $notnull_bool(i < invoke.inputs.length); i++) {
-    if ($notnull_bool(i != 0)) arguments.add(", ");
+   i < invoke.inputs.length; i++) {
+    if (i != 0) arguments.add(", ");
     arguments.add(this.temporaryId((($0 = invoke.inputs.$index(i)) && $0.is$HInstruction())));
   }
   return ("" + invokeType + ": " + invoke.selector + "(" + arguments + ")");
 }
 HInstructionStringifier.prototype.visitInvoke = function(invoke) {
   return this.visitGenericInvoke("Invoke", invoke);
 }
 HInstructionStringifier.prototype.visitInvokeForeign = function(invoke) {
   return this.visitGenericInvoke("InvokeForeign", invoke);
 }
@@ skipping 40 matching lines @@
 $inherits(HValidator, HInstructionVisitor);
 HValidator.prototype.visitGraph = function(graph) {
   this.graph = graph;
   this.visitDominatorTree(graph);
 }
 HValidator.prototype.markInvalid = function(reason) {
   print(reason);
   this.isValid = false;
 }
 HValidator.prototype.visitBasicBlock = function(block) {
-  if ($notnull_bool(!$notnull_bool(this.isValid))) return;
-  if ($notnull_bool(block.first == null || block.last == null)) {
+  if (!$notnull_bool(this.isValid)) return;
+  if (block.first == null || block.last == null) {
     this.markInvalid("empty block");
   }
-  if ($notnull_bool(!(block.last instanceof HControlFlow))) {
+  if (!(block.last instanceof HControlFlow)) {
     this.markInvalid("block ends with non-tail node.");
   }
-  if ($notnull_bool((block.last instanceof HIf) && block.successors.length != 2)) {
+  if ((block.last instanceof HIf) && block.successors.length != 2) {
     this.markInvalid("If node without two successors");
   }
-  if ($notnull_bool((block.last instanceof HConditionalBranch) && block.successors.length != 2)) {
+  if ((block.last instanceof HConditionalBranch) && block.successors.length != 2) {
     this.markInvalid("Conditional node without two successors");
   }
-  if ($notnull_bool((block.last instanceof HGoto) && block.successors.length != 1)) {
+  if ((block.last instanceof HGoto) && block.successors.length != 1) {
     this.markInvalid("Goto node without one successor");
   }
-  if ($notnull_bool((block.last instanceof HReturn) && ($notnull_bool(block.successors.length != 1 || !$notnull_bool(block.successors.$index(0).isExitBlock()))))) {
+  if ((block.last instanceof HReturn) && (block.successors.length != 1 || !$notnull_bool(block.successors.$index(0).isExitBlock()))) {
     this.markInvalid("Return node with > 1 succesor or not going to exit-block");
   }
-  if ($notnull_bool((block.last instanceof HExit) && !$notnull_bool(block.successors.isEmpty()))) {
+  if ((block.last instanceof HExit) && !block.successors.isEmpty()) {
     this.markInvalid("Exit block with successor");
   }
-  if ($notnull_bool((block.last instanceof HThrow) && !$notnull_bool(block.successors.isEmpty()))) {
+  if ((block.last instanceof HThrow) && !block.successors.isEmpty()) {
     this.markInvalid("Throw block with successor");
   }
-  if ($notnull_bool(block.successors.isEmpty() && !(block.last instanceof HThrow)) && !$notnull_bool(block.isExitBlock())) {
+  if (block.successors.isEmpty() && !(block.last instanceof HThrow) && !$notnull_bool(block.isExitBlock())) {
     this.markInvalid("Non-exit or throw block without successor");
   }
-  if ($notnull_bool(block.id == null)) this.markInvalid("block without id");
+  if (block.id == null) this.markInvalid("block without id");
   var $list = block.successors;
   for (var $i = 0;$i < $list.length; $i++) {
     var successor = $list.$index($i);
-    if ($notnull_bool(!$notnull_bool(this.isValid))) break;
-    if ($notnull_bool(successor.id == null)) this.markInvalid("successor without id");
-    if ($notnull_bool(successor.id <= block.id && !$notnull_bool(successor.isLoopHeader))) {
+    if (!$notnull_bool(this.isValid)) break;
+    if (successor.id == null) this.markInvalid("successor without id");
+    if (successor.id <= block.id && !$notnull_bool(successor.isLoopHeader)) {
       this.markInvalid("successor with lower id, but not a loop-header");
     }
   }
   var lastId = 0;
   var $list = block.dominatedBlocks;
   for (var $i = 0;$i < $list.length; $i++) {
     var dominated = $list.$index($i);
-    if ($notnull_bool(!$notnull_bool(this.isValid))) break;
-    if ($notnull_bool(dominated.dominator !== block)) {
+    if (!$notnull_bool(this.isValid)) break;
+    if (dominated.dominator !== block) {
       this.markInvalid("dominated block not pointing back");
     }
-    if ($notnull_bool(dominated.id == null || dominated.id <= lastId)) {
+    if (dominated.id == null || dominated.id <= lastId) {
       this.markInvalid("dominated.id === null or dominated has <= id");
     }
     lastId = dominated.id;
   }
-  if ($notnull_bool(!$notnull_bool(this.isValid))) return;
+  if (!$notnull_bool(this.isValid)) return;
   HInstructionVisitor.prototype.visitBasicBlock.call(this, block);
 }
 HValidator.countInstruction = function(instructions, instruction) {
   var result = 0;
   for (var i = 0;
-   $notnull_bool(i < instructions.length); i++) {
-    if ($notnull_bool(instructions.$index(i) === instruction)) result++;
+   i < instructions.length; i++) {
+    if (instructions.$index(i) === instruction) result++;
   }
   return result;
 }
 HValidator.everyInstruction = function(instructions, f) {
   var copy = ListFactory.ListFactory$from$factory(instructions);
   for (var i = 0;
-   $notnull_bool(i < copy.length); i++) {
+   i < copy.length; i++) {
     var current = copy.$index(i);
-    if ($notnull_bool(current == null)) continue;
+    if (current == null) continue;
     var count = 1;
     for (var j = i + 1;
-     $notnull_bool(j < copy.length); j++) {
-      if ($notnull_bool(copy.$index(j) === current)) {
+     j < copy.length; j++) {
+      if (copy.$index(j) === current) {
         copy.$setindex(j);
         count++;
       }
     }
-    if ($notnull_bool(!$notnull_bool(f.call$2(current, count)))) return false;
+    if (!$notnull_bool(f.call$2(current, count))) return false;
   }
   return true;
 }
 HValidator.prototype.visitInstruction = function(instruction) {
   var $this = this; // closure support
   function hasCorrectInputs(instruction) {
     var inBasicBlock = instruction.isInBasicBlock();
     return HValidator.everyInstruction(instruction.inputs, (function (input, count) {
       if ($notnull_bool(inBasicBlock)) {
         return HValidator.countInstruction(input.get$usedBy(), (instruction && instruction.is$HInstruction())) == count;
       }
       else {
         return HValidator.countInstruction(input.get$usedBy(), (instruction && instruction.is$HInstruction())) == 0;
       }
     })
     );
   }
   function hasCorrectUses(instruction) {
-    if ($notnull_bool(!$notnull_bool(instruction.isInBasicBlock()))) return true;
+    if (!$notnull_bool(instruction.isInBasicBlock())) return true;
     return HValidator.everyInstruction(instruction.get$usedBy(), (function (use, count) {
       return HValidator.countInstruction(use.inputs, (instruction && instruction.is$HInstruction())) == count;
     })
     );
   }
-  this.isValid = $notnull_bool(this.isValid && hasCorrectInputs(instruction)) && hasCorrectUses(instruction);
+  this.isValid = $notnull_bool($notnull_bool(this.isValid && hasCorrectInputs(instruction)) && hasCorrectUses(instruction));
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldCompiler **************
 function WorldCompiler(world, script) {
   this.world = world;
   Compiler.call(this, script);
   // Initializers done
 }
 $inherits(WorldCompiler, Compiler);
@@ skipping 12 matching lines @@
     for (var $i0 = 0;$i0 < $list.length; $i0++) {
       var task = $list.$index($i0);
       this.log(('' + task.get$name() + ' took ' + task.get$timing() + 'msec'));
     }
   }
   return success;
 }
 WorldCompiler.prototype.spanFromNode = function(node) {
   var begin = node.getBeginToken();
   var end = node.getEndToken();
-  if ($notnull_bool(begin == null || end == null)) {
+  if (begin == null || end == null) {
     this.cancel(('cannot find tokens to produce error message for ' + node + '.'));
   }
   var startOffset = begin.get$charOffset();
   var endOffset = end.get$charOffset() + end.toString().length;
   return new SourceSpan(this.script.file, startOffset, endOffset);
 }
 WorldCompiler.prototype.reportWarning = function(node, message) {
   var $0;
   this.world.warning(('' + message + '.'), (($0 = this.spanFromNode(node)) && $0.is$SourceSpan()));
 }
 // ********** Code for Compiler **************
 function Compiler(script) {
   this.script = script;
   // Initializers done
   this.universe = new Universe();
   this.worklist = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([const$3/*Compiler.MAIN*/]);
   this.scanner = new ScannerTask(this);
   this.parser = new ParserTask(this);
   this.resolver = new ResolverTask(this);
   this.checker = new TypeCheckerTask(this);
   this.builder = new SsaBuilderTask(this);
   this.optimizer = new SsaOptimizerTask(this);
   this.generator = new SsaCodeGeneratorTask(this);
   this.tasks = [this.scanner, this.parser, this.resolver, this.checker, this.builder, this.optimizer, this.generator];
 }
 Compiler.prototype.ensure = function(condition) {
-  if ($notnull_bool(!$notnull_bool(condition))) this.cancel('failed assertion in leg');
+  if (!$notnull_bool(condition)) this.cancel('failed assertion in leg');
 }
 Compiler.prototype.unimplemented = function(methodName) {
   this.cancel(("" + methodName + " not implemented"));
 }
 Compiler.prototype.cancel = function(reason) {
   $throw(new CompilerCancelledException(reason));
 }
 Compiler.prototype.log = function(message) {
 
 }
 Compiler.prototype.run = function() {
   try {
     this.runCompiler();
   } catch (exception) {
     exception = $toDartException(exception);
     if (!(exception instanceof CompilerCancelledException)) throw exception;
     this.log(exception.toString());
     this.log('compilation failed');
     return false;
   }
-  if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
+  if (false/*null.GENERATE_SSA_TRACE*/) {
     print("------------------");
     print(HTracer.HTracer$singleton$factory());
     print("------------------");
   }
   this.log('compilation succeeded');
   return true;
 }
 Compiler.prototype.scanCoreLibrary = function() {
   var fileName = join([options.libDir, '..', 'leg', 'lib', 'core.dart']);
   var file = readSync(fileName);
   this.scanner.scan(new leg_Script(file));
   var element = new ForeignElement(const$243/*const SourceString('JS')*/);
   this.universe.define(element);
 }
 Compiler.prototype.runCompiler = function() {
   var $0;
   this.scanCoreLibrary();
   this.scanner.scan(this.script);
-  while ($notnull_bool(!$notnull_bool(this.worklist.isEmpty()))) {
+  while (!this.worklist.isEmpty()) {
     this.compileMethod((($0 = this.worklist.removeLast()) && $0.is$SourceString()));
   }
 }
 Compiler.prototype.compileMethod = function(name) {
   var element = this.universe.find(name);
-  if ($notnull_bool(element == null)) this.cancel(('Could not find ' + name + ''));
+  if (element == null) this.cancel(('Could not find ' + name + ''));
   var tree = this.parser.parse(element);
   var elements = this.resolver.resolve(tree);
   this.checker.check(tree, elements);
   var graph = this.builder.build(tree, elements);
   this.optimizer.optimize(graph);
   var code = this.generator.generate(tree, graph);
   this.universe.addGeneratedCode(element, code);
   return code;
 }
 Compiler.prototype.getGeneratedCode = function() {
   var $0;
   var buffer = new StringBufferImpl("");
   buffer.add("function $add(a, b) {\n  return a + b;\n}\n"/*null.ADD_SUPPORT*/);
   buffer.add("function $div(a, b) {\n  return a / b;\n}\n"/*null.DIV_SUPPORT*/);
   buffer.add("function $eq(a, b) {\n  return a === b;\n}\n"/*null.EQ_SUPPORT*/);
   buffer.add("function $sub(a, b) {\n  return a - b;\n}\n"/*null.SUB_SUPPORT*/);
   buffer.add("function $mul(a, b) {\n  return a * b;\n}\n"/*null.MUL_SUPPORT*/);
   buffer.add("function $tdiv(a, b) {\n  var tmp = this / other;\n  if (tmp < 0) {\n    return Math.ceil(tmp);\n  } else {\n    return Math.floor(tmp);\n  }\n}\n"/*null.TDIV_SUPPORT*/);
   var codeBlocks = (($0 = this.universe.generatedCode.getValues()) && $0.is$List$String());
   for (var i = codeBlocks.length - 1;
-   $notnull_bool(i >= 0); i--) {
+   i >= 0; i--) {
     buffer.add(codeBlocks.$index(i));
   }
   buffer.add('main();\n');
   return buffer.toString();
 }
 Compiler.prototype.reportWarning = function(node, message) {
 
 }
 // ********** Code for CompilerTask **************
 function CompilerTask(compiler) {
@@ skipping 13 matching lines @@
   this.watch.stop();
   return result;
 }
 // ********** Code for CompilerCancelledException **************
 function CompilerCancelledException(reason) {
   this.reason = reason;
   // Initializers done
 }
 CompilerCancelledException.prototype.toString = function() {
   var banner = 'compiler cancelled';
-  return $notnull_bool((this.reason != null)) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
+  return (this.reason != null) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
 }
 // ********** Code for ResolverTask **************
 function ResolverTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(ResolverTask, CompilerTask);
 ResolverTask.prototype.get$name = function() {
   return 'Resolver';
 }
@@ skipping 25 matching lines @@
   this.context = new Scope(new TopScope(compiler.universe));
   // Initializers done
 }
 ResolverVisitor.prototype.fail = function(node, message) {
   this.compiler.cancel(message);
 }
 ResolverVisitor.prototype.warning = function(node, message) {
   this.compiler.reportWarning(node, message);
 }
 ResolverVisitor.prototype.visit = function(node) {
-  if ($notnull_bool(node == null)) return null;
+  if (node == null) return null;
   return node.accept(this);
 }
 ResolverVisitor.prototype.visitIn = function(node, scope) {
   var $0;
   this.context = scope;
   var element = (($0 = this.visit(node)) && $0.is$Element());
   this.context = this.context.parent;
   return element;
 }
 ResolverVisitor.prototype.visitBlock = function(node) {
@@ skipping 12 matching lines @@
 ResolverVisitor.prototype.visitFunctionExpression = function(node) {
   var $0;
   var enclosingElement = (($0 = this.visit(node.name)) && $0.is$Element());
   var newScope = new Scope.enclosing$ctor(this.context, enclosingElement);
   this.visitIn(node.parameters, newScope);
   this.visitIn(node.body, newScope);
   return enclosingElement;
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   var element = this.context.lookup(node.get$source());
-  if ($notnull_bool(element == null)) this.fail(node, ErrorMessages.cannotResolve(node));
+  if (element == null) this.fail(node, ErrorMessages.cannotResolve(node));
   return this.useElement(node, element);
 }
 ResolverVisitor.prototype.visitIf = function(node) {
   this.visit(node.condition);
   this.visit(node.thenPart);
   this.visit(node.elsePart);
 }
 ResolverVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = null;
   this.visit(node.receiver);
   var selector = (($0 = node.selector) && $0.is$Identifier());
   var name = selector.get$source();
-  if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$248/*const SourceString('-')*/)) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/) || $eq(name, const$253/*const SourceString('==')*/)) {
+  if ($notnull_bool($notnull_bool($notnull_bool($notnull_bool($notnull_bool($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$248/*const SourceString('-')*/)) || $eq(name, const$249/*const SourceString('*')*/)) || $eq(name, const$250/*const SourceString('/')*/)) || $eq(name, const$251/*const SourceString('<')*/)) || $eq(name, const$252/*const SourceString('~/')*/)) || $eq(name, const$253/*const SourceString('==')*/))) {
   }
   else {
     target = this.context.lookup(name);
-    if ($notnull_bool(target == null)) this.fail(node, ErrorMessages.cannotResolve(name));
+    if (target == null) this.fail(node, ErrorMessages.cannotResolve(name));
   }
   this.visit(node.argumentsNode);
   return this.useElement(node, target);
 }
 ResolverVisitor.prototype.visitSendSet = function(node) {
   var $0;
   var receiver = (($0 = this.visit(node.receiver)) && $0.is$Element());
   var selector = (($0 = node.selector) && $0.is$Identifier());
-  if ($notnull_bool(receiver != null)) {
+  if (receiver != null) {
     this.compiler.unimplemented('Resolver: property access');
   }
   var target = this.context.lookup(selector.get$source());
-  if ($notnull_bool(target == null)) this.fail(node, ErrorMessages.cannotResolve(node));
+  if (target == null) this.fail(node, ErrorMessages.cannotResolve(node));
   this.visit(node.argumentsNode);
   return this.useElement(node, target);
 }
 ResolverVisitor.prototype.visitLiteralInt = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralDouble = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralBool = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralString = function(node) {
 
 }
 ResolverVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 ResolverVisitor.prototype.visitOperator = function(node) {
   this.fail(node, "Unimplemented in the resolver");
 }
 ResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitThrow = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitTypeAnnotation = function(node) {
   var name = node.typeName;
   if ($notnull_bool($eq(name.get$source(), const$254/*const SourceString('var')*/))) return null;
   var element = this.context.lookup(name.get$source());
-  if ($notnull_bool(element == null)) {
+  if (element == null) {
     this.warning(node, ErrorMessages.cannotResolveType(name));
   }
   return this.useElement(node, element);
 }
 ResolverVisitor.prototype.visitVariableDefinitions = function(node) {
   this.visit(node.type);
   var visitor = new VariableDefinitionsVisitor(node, this);
   visitor.visit(node.definitions);
 }
 ResolverVisitor.prototype.defineElement = function(node, element) {
   var $0;
   this.compiler.ensure(element != null);
   this.mapping.$setindex(node, element);
   return (($0 = this.context.add(element)) && $0.is$Element());
 }
 ResolverVisitor.prototype.useElement = function(node, element) {
-  if ($notnull_bool(element == null)) return null;
+  if (element == null) return null;
   this.mapping.$setindex(node, element);
   return element;
 }
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
   this.definitions = definitions;
   this.resolver = resolver;
   // Initializers done
 }
 VariableDefinitionsVisitor.prototype.visitSendSet = function(node) {
   var $0;
   $assert(node.get$arguments().get$tail().isEmpty(), "node.arguments.tail.isEmpty()", "resolver.dart", 200, 12);
-  if ($notnull_bool(node.receiver != null)) {
+  if (node.receiver != null) {
     this.resolver.compiler.unimplemented("receiver on a variable definition");
   }
   var selector = (($0 = node.selector) && $0.is$Identifier());
   this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   return (($0 = this.visit(node.selector)) && $0.is$SourceString());
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   return node.get$source();
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var name = (($0 = this.visit((($0 = link.get$head()) && $0.is$Node()))) && $0.is$SourceString());
     var element = new VariableElement((($0 = link.get$head()) && $0.is$Node()), this.definitions.type, name, this.resolver.context.enclosingElement);
     var existing = this.resolver.defineElement((($0 = link.get$head()) && $0.is$Node()), element);
-    if ($notnull_bool($ne(existing, element))) {
+    if ($ne(existing, element)) {
       this.resolver.fail(node, ErrorMessages.duplicateDefinition(link.get$head()));
     }
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 // ********** Code for Scope **************
 function Scope(parent) {
   Scope.enclosing$ctor.call(this, parent, parent.enclosingElement);
@@ skipping 10 matching lines @@
   this.parent = parent;
   this.enclosingElement = enclosingElement;
   this.elements = $map([]);
   // Initializers done
 }
 Scope.enclosing$ctor.prototype = Scope.prototype;
 Scope.prototype.get$parent = function() { return this.parent; };
 Scope.prototype.lookup = function(name) {
   var $0;
   var element = (($0 = this.elements.$index(name)) && $0.is$Element());
-  if ($notnull_bool(element != null)) return element;
+  if (element != null) return element;
   return this.parent.lookup(name);
 }
 Scope.prototype.add = function(element) {
   var $0;
-  if ($notnull_bool(this.elements.containsKey(element.name))) return (($0 = this.elements.$index(element.name)) && $0.is$Element());
+  if (this.elements.containsKey(element.name)) return (($0 = this.elements.$index(element.name)) && $0.is$Element());
   this.elements.$setindex(element.name, element);
   return element;
 }
 // ********** Code for TopScope **************
 function TopScope(universe) {
   this.universe = universe;
   Scope.top$ctor.call(this);
   // Initializers done
 }
 $inherits(TopScope, Scope);
@@ skipping 100 matching lines @@
   }
   else if ($notnull_bool($eq(const$10/*Types.DYNAMIC*/, s) || s.get$stringValue() === 'var')) {
     return this.dynamicType;
   }
   else if ($notnull_bool($eq(const$12/*Types.STRING*/, s))) {
     return this.stringType;
   }
   return null;
 }
 Types.prototype.isSubtype = function(r, s) {
-  return $notnull_bool(r === s || r === this.dynamicType) || s === this.dynamicType;
+  return r === s || r === this.dynamicType || s === this.dynamicType;
 }
 Types.prototype.isAssignable = function(r, s) {
   return $notnull_bool(this.isSubtype(r, s) || this.isSubtype(s, r));
 }
 // ********** Code for CancelTypeCheckException **************
 function CancelTypeCheckException(node, reason) {
   this.node = node;
   this.reason = reason;
   // Initializers done
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(compiler, elements, types) {
   this.compiler = compiler;
   this.elements = elements;
   this.types = types;
   // Initializers done
 }
 TypeCheckerVisitor.prototype.fail = function(node, reason) {
   var message = 'cannot type-check';
-  if ($notnull_bool(reason != null)) {
+  if (reason != null) {
     message = ('' + message + ': ' + reason + '');
   }
   $throw(new CancelTypeCheckException(node, message));
 }
 TypeCheckerVisitor.prototype.nonVoidType = function(node) {
   var type = this.type(node);
-  if ($notnull_bool($eq(type, this.types.voidType))) {
+  if ($eq(type, this.types.voidType)) {
     this.compiler.reportWarning(node, CompilerError.voidExpression());
   }
   return type;
 }
 TypeCheckerVisitor.prototype.typeWithDefault = function(node, defaultValue) {
-  return $notnull_bool(node != null) ? this.type(node) : defaultValue;
+  return node != null ? this.type(node) : defaultValue;
 }
 TypeCheckerVisitor.prototype.type = function(node) {
   var $0;
-  if ($notnull_bool(node == null)) this.fail(null, 'unexpected node: null');
+  if (node == null) this.fail(null, 'unexpected node: null');
   var result = (($0 = node.accept(this)) && $0.is$Type());
   return result;
 }
 TypeCheckerVisitor.prototype.checkAssignable = function(node, s, t) {
-  if ($notnull_bool(!$notnull_bool(this.types.isAssignable(s, t)))) {
+  if (!$notnull_bool(this.types.isAssignable(s, t))) {
     var error = CompilerError.notAssignable(s, t);
     this.compiler.reportWarning(node, error);
   }
 }
 TypeCheckerVisitor.prototype.visitBlock = function(node) {
   this.type(node.statements);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitClassNode = function(node) {
   this.fail(node);
@@ skipping 19 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitIf = function(node) {
   this.type(node.condition);
   this.type(node.thenPart);
   if ($notnull_bool(node.get$hasElsePart())) this.type(node.elsePart);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = this.elements.$index(node);
-  if ($notnull_bool(target != null)) {
+  if (target != null) {
     var targetType = target.computeType(this.compiler, this.types);
     if ($notnull_bool(node.get$isPropertyAccess())) {
       return (targetType && targetType.is$Type());
     }
     else if ($notnull_bool(node.get$isFunctionObjectInvocation())) {
       this.fail(node);
     }
     else {
-      if ($notnull_bool(!(targetType instanceof FunctionType))) {
-        if ($notnull_bool((target instanceof ForeignElement))) {
+      if (!(targetType instanceof FunctionType)) {
+        if ((target instanceof ForeignElement)) {
           return this.types.dynamicType;
         }
         this.fail(node, 'can only handle function types');
       }
       var funType = (targetType && targetType.is$FunctionType());
       var formals = funType.parameterTypes;
       var arguments = node.get$arguments();
-      while ($notnull_bool((!$notnull_bool(formals.isEmpty())) && (!$notnull_bool(arguments.isEmpty())))) {
+      while ((!$notnull_bool(formals.isEmpty())) && (!$notnull_bool(arguments.isEmpty()))) {
         var argument = (($0 = arguments.get$head()) && $0.is$Node());
         var argumentType = this.type(argument);
         this.checkAssignable(argument, argumentType, (($0 = formals.get$head()) && $0.is$Type()));
         formals = (($0 = formals.get$tail()) && $0.is$Link$Type());
         arguments = (($0 = arguments.get$tail()) && $0.is$Link$Node());
       }
-      if ($notnull_bool(!$notnull_bool(formals.isEmpty()))) {
+      if (!$notnull_bool(formals.isEmpty())) {
         this.compiler.reportWarning(node, 'missing argument');
       }
-      if ($notnull_bool(!$notnull_bool(arguments.isEmpty()))) {
+      if (!$notnull_bool(arguments.isEmpty())) {
         this.compiler.reportWarning(arguments.get$head(), 'additional arguments');
       }
       return funType.returnType;
     }
   }
   else {
     var selector = (($0 = node.selector) && $0.is$Identifier());
     var name = selector.get$source();
-    if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$257/*const SourceString('=')*/)) || $eq(name, const$248/*const SourceString('-')*/) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/)) {
+    if ($notnull_bool($notnull_bool($notnull_bool($notnull_bool($notnull_bool($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$257/*const SourceString('=')*/)) || $eq(name, const$248/*const SourceString('-')*/)) || $eq(name, const$249/*const SourceString('*')*/)) || $eq(name, const$250/*const SourceString('/')*/)) || $eq(name, const$251/*const SourceString('<')*/)) || $eq(name, const$252/*const SourceString('~/')*/))) {
       return this.types.dynamicType;
     }
     this.fail(node, ('unresolved send ' + name + ''));
   }
 }
 TypeCheckerVisitor.prototype.visitSendSet = function(node) {
   var $0;
-  this.compiler.ensure($notnull_bool(node.get$arguments() != null && !$notnull_bool(node.get$arguments().isEmpty())));
+  this.compiler.ensure(node.get$arguments() != null && !$notnull_bool(node.get$arguments().isEmpty()));
   var targetType = (($0 = this.elements.$index(node).computeType(this.compiler, this.types)) && $0.is$Type());
   var value = (($0 = node.get$arguments().get$head()) && $0.is$Node());
   this.checkAssignable(value, this.type(value), targetType);
   return targetType;
 }
 TypeCheckerVisitor.prototype.visitLiteralInt = function(node) {
   return this.types.intType;
 }
 TypeCheckerVisitor.prototype.visitLiteralDouble = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitLiteralBool = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitLiteralString = function(node) {
   return this.types.stringType;
 }
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.type((($0 = link.get$head()) && $0.is$Node()));
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.dynamicType;
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expression = node.expression;
   var isVoidFunction = (this.expectedReturnType === this.types.voidType);
-  if ($notnull_bool(expression != null)) {
+  if (expression != null) {
     var expressionType = this.type(expression);
-    if ($notnull_bool(isVoidFunction && !$notnull_bool(this.types.isAssignable(expressionType, this.types.voidType)))) {
+    if (isVoidFunction && !$notnull_bool(this.types.isAssignable(expressionType, this.types.voidType))) {
       this.compiler.reportWarning(expression, CompilerError.returnValueInVoid());
     }
     else {
       this.checkAssignable(expression, expressionType, this.expectedReturnType);
     }
   }
-  else if ($notnull_bool(!$notnull_bool(this.types.isAssignable(this.expectedReturnType, this.types.voidType)))) {
+  else if (!$notnull_bool(this.types.isAssignable(this.expectedReturnType, this.types.voidType))) {
     var error = CompilerError.returnNothing(this.expectedReturnType);
     this.compiler.reportWarning(node, error);
   }
   return null;
 }
 TypeCheckerVisitor.prototype.visitThrow = function(node) {
-  if ($notnull_bool(node.expression != null)) this.type(node.expression);
+  if (node.expression != null) this.type(node.expression);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitTypeAnnotation = function(node) {
-  if ($notnull_bool(node.typeName == null)) return this.types.dynamicType;
+  if (node.typeName == null) return this.types.dynamicType;
   var name = node.typeName.get$source();
   var type = this.types.lookup(name);
-  if ($notnull_bool(type == null)) this.fail(node, ('unsupported type ' + name + ''));
+  if (type == null) this.fail(node, ('unsupported type ' + name + ''));
   return type;
 }
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   var $0;
   var type = this.typeWithDefault(node.type, this.types.dynamicType);
-  if ($notnull_bool($eq(type, this.types.voidType))) {
+  if ($eq(type, this.types.voidType)) {
     this.compiler.reportWarning(node.type, CompilerError.voidVariable());
     type = this.types.dynamicType;
   }
   for (var link = node.definitions.nodes;
-   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   !$notnull_bool(link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var initialization = (($0 = link.get$head()) && $0.is$Node());
-    this.compiler.ensure($notnull_bool((initialization instanceof Identifier) || (initialization instanceof Send)));
-    if ($notnull_bool((initialization instanceof Send))) {
+    this.compiler.ensure((initialization instanceof Identifier) || (initialization instanceof Send));
+    if ((initialization instanceof Send)) {
       var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$Node()));
       this.checkAssignable(node, type, initializer);
     }
   }
   return null;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
@@ skipping 30 matching lines @@
   this._buf = new StringBufferImpl("");
   // Initializers done
 }
 CodeWriter.prototype.is$CodeWriter = function(){return this;};
 CodeWriter.prototype.get$text = function() {
   return this._buf.toString();
 }
 CodeWriter.prototype._indent = function() {
   this._pendingIndent = false;
   for (var i = 0;
-   $notnull_bool(i < this._indentation); i++) {
+   i < this._indentation; i++) {
     this._buf.add('  '/*CodeWriter.INDENTATION*/);
   }
 }
 CodeWriter.prototype.comment = function(text) {
   if ($notnull_bool(this.writeComments)) {
     this.writeln(text);
   }
 }
 CodeWriter.prototype.write = function(text) {
-  if ($notnull_bool(text.length == 0)) return;
+  if (text.length == 0) return;
   if ($notnull_bool(this._pendingIndent)) this._indent();
-  if ($notnull_bool(text.indexOf('\n', 0) != -1)) {
+  if (text.indexOf('\n', 0) != -1) {
     var lines = text.split('\n');
     for (var i = 0;
-     $notnull_bool(i < lines.length - 1); i++) {
+     i < lines.length - 1; i++) {
       this.writeln($assert_String(lines.$index(i)));
     }
     this.write($assert_String(lines.$index(lines.length - 1)));
   }
   else {
     this._buf.add(text);
   }
 }
 CodeWriter.prototype.writeln = function(text) {
-  if ($notnull_bool(text != null)) {
+  if (text != null) {
     this.write(text);
   }
-  if ($notnull_bool(!$notnull_bool(text.endsWith('\n')))) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
+  if (!text.endsWith('\n')) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
   this._pendingIndent = true;
 }
 CodeWriter.prototype.enterBlock = function(text) {
   this.writeln(text);
   this._indentation++;
 }
 CodeWriter.prototype.exitBlock = function(text) {
   this._indentation--;
   this.writeln(text);
 }
@@ skipping 78 matching lines @@
     w.writeln("/**\n * Generates a dynamic call stub for a function.\n * Our goal is to create a stub method like this on-the-fly:\n *   function($0, $1, capture) { this($0, $1, true, capture); }\n *\n * This stub then replaces the dynamic one on Function, with one that is\n * specialized for that particular function, taking into account its default\n * arguments.\n */\nFunction.prototype.$genStub = function(argsLength, names) {\n  // TODO(jmesserly): only emit $genStub if actually needed\n\n  // Fast path: if no named arguments and arg count matches\n  if (this.length == argsLength && !names) {\n    return this;\n  }\n\n  function $throwArgMismatch() {\n    // TODO(jmesserly): better error message\n    $throw(new ClosureArgumentMismatchException());\n  }\n\n  var paramsNamed = this.$optional ? (this.$optional.length / 2) : 0;\n  var paramsBare = this.length - paramsNamed;\n  var argsNamed = names ? names.length : 0;\n  var argsBare = argsLength - argsNamed;\n\n  // Check we got the right number of arguments\n  if (argsBare < paramsBare || argsLength > this.length ||\n      argsNamed > paramsNamed) {\n    return $throwArgMismatch;\n  }\n\n  // First, fill in all of the default values\n  var p = new Array(paramsBare);\n  if (paramsNamed) {\n    p = p.concat(this.$optional.slice(paramsNamed));\n  }\n  // Fill in positional args\n  var a = new Array(argsLength);\n  for (var i = 0; i < argsBare; i++) {\n    p[i] = a[i] = '$' + i;\n  }\n  // Then overwrite with supplied values for optional args\n  var lastParameterIndex;\n  var namesInOrder = true;\n  for (var i = 0; i < argsNamed; i++) {\n    var name = names[i];\n    a[i + argsBare] = name;\n    var j = this.$optional.indexOf(name, 0);\n    if (j < 0 || j >= paramsNamed) {\n      return $throwArgMismatch;\n    } else if (lastParameterIndex && lastParameterIndex > j) {\n      namesInOrder = false;\n    }\n    p[j + paramsBare] = name;\n    lastParameterIndex = j;\n  }\n\n  if (this.length == argsLength && namesInOrder) {\n    // Fast path #2: named arguments, but they're in order.\n    return this;\n  }\n\n  // Note: using Function instead of 'eval' to get a clean scope.\n  // TODO(jmesserly): evaluate the performance of these stubs.\n  var f = 'function(' + a.join(',') + '){return $f(' + p.join(',') + ');}';\n  return new Function('$f', 'return ' + f + '').call(null, this);\n}");
   }
   if ($notnull_bool(this.useStackTraceOf)) {
     w.writeln("function $stackTraceOf(e) {\n  // TODO(jmesserly): we shouldn't be relying on the e.stack property.\n  // Need to mangle it.\n  return e.stack ? e.stack : null;\n}");
   }
   if ($notnull_bool(this.useToDartException)) {
     w.writeln("// Translate a JavaScript exception to a Dart exception\n// TODO(jmesserly): cross browser support. This is Chrome specific.\nfunction $toDartException(e) {\n  var res = e;\n  if (e instanceof TypeError) {\n    switch(e.type) {\n      case 'property_not_function':\n      case 'called_non_callable':\n        if (e.arguments[0] == null) {\n          res = new NullPointerException();\n        } else {\n          res = new ObjectNotClosureException();\n        }\n        break;\n      case 'non_object_property_call':\n      case 'non_object_property_load':\n        res = new NullPointerException();\n        break;\n      case 'undefined_method':\n        if (e.arguments[0] == 'call' || e.arguments[0] == 'apply') {\n          res = new ObjectNotClosureException();\n        } else {\n          // TODO(jmesserly): can this ever happen?\n          res = new NoSuchMethodException('', e.arguments[0], []);\n        }\n        break;\n    }\n  } else if (e instanceof RangeError) {\n    if (e.message.indexOf('call stack') >= 0) {\n      res = new StackOverflowException();\n    }\n  }\n  // TODO(jmesserly): setting the stack property is not a long term solution.\n  // Also it causes the exception to print as if it were a TypeError or\n  // RangeError, instead of using the proper toString.\n  res.stack = e.stack;\n  return res;\n}");
   }
   if ($notnull_bool(this.useNotNullBool)) {
     this.useThrow = true;
-    w.writeln("function $notnull_bool(test) {\n  return typeof(test) == 'boolean' ? test : test.is$bool();\n}");
+    w.writeln("function $notnull_bool(test) {\n  return (test === true || test === false) ? test : test.is$bool();\n}");
   }
   if ($notnull_bool(this.useAssert)) {
     this.useThrow = true;
     w.writeln("function $assert(test, text, url, line, column) {\n  if (typeof test == 'function') test = test();\n  if (!test) $throw(new AssertError(text, url, line, column));\n}");
   }
   if ($notnull_bool(this.useThrow)) {
     w.writeln("function $throw(e) {\n  // If e is not a value, we can use V8's captureStackTrace utility method.\n  // TODO(jmesserly): capture the stack trace on other JS engines.\n  if (e && (typeof e == 'object') && Error.captureStackTrace) {\n    // TODO(jmesserly): this will clobber the e.stack property\n    Error.captureStackTrace(e, $throw);\n  }\n  throw e;\n}");
   }
   if ($notnull_bool(this.useMap)) {
     w.writeln("function $map(items) {\n  var ret = new HashMapImplementation();\n  for (var i=0; i < items.length;) {\n    ret.$setindex(items[i++], items[i++]);\n  }\n  return ret;\n}");
@@ skipping 37 matching lines @@
   this.genMethod((($0 = world.get$coreimpl().types.$index('MatchImplementation').getConstructor('')) && $0.is$Member()));
   this.writeTypes(world.get$coreimpl());
   this.writeTypes(world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
   this._writeGlobals();
   this.writer.writeln(('RunEntry(function () {' + mainCall.code + ';}, []);'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
   var $0;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
-  if ($notnull_bool(!$notnull_bool(this.globals.containsKey(fullname)))) {
+  if (!this.globals.containsKey(fullname)) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
   return (($0 = this.globals.$index(fullname)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var $0;
   var code = exp.canonicalCode;
-  if ($notnull_bool(!$notnull_bool(this.globals.containsKey(code)))) {
+  if (!this.globals.containsKey(code)) {
     this.globals.$setindex(code, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
   return (($0 = this.globals.$index(code)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if ($notnull_bool(lib.isWritten)) return;
   lib.isWritten = true;
   var $list = lib.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var import_ = $list.$index($i);
     this.writeTypes(import_.get$library());
   }
   for (var i = 0;
-   $notnull_bool(i < lib.sources.length); i++) {
+   i < lib.sources.length; i++) {
     lib.sources.$index(i).orderInLibrary = i;
   }
   this.writer.comment(('//  ********** Library ' + lib.name + ' **************'));
   if ($notnull_bool(lib.get$isCore())) {
     this.writer.comment('//  ********** Natives dart:core **************');
     this.corejs.generate(this.writer);
   }
   var $list = lib.natives;
   for (var $i = 0;$i < $list.length; $i++) {
     var file = $list.$index($i);
@@ skipping 12 matching lines @@
         for (var $i0 = 0;$i0 < $list0.length; $i0++) {
           var ct = $list0.$index($i0);
           this.writeType((ct && ct.is$lang_Type()));
         }
       }
     }
     if ($notnull_bool(type.get$isFunction() && type.varStubs != null)) {
       this.writer.comment(('// ********** Code for ' + type.get$jsname() + ' **************'));
       this._writeDynamicStubs((type && type.is$lang_Type()));
     }
-    if ($notnull_bool(type.typeCheckCode != null)) {
+    if (type.typeCheckCode != null) {
       this.writer.writeln(type.typeCheckCode);
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
-  if ($notnull_bool(!$notnull_bool(meth.isGenerated) && !$notnull_bool(meth.get$isAbstract())) && $ne(meth.get$definition(), null)) {
+  if ($notnull_bool(!$notnull_bool(meth.isGenerated) && !$notnull_bool(meth.get$isAbstract()) && $ne(meth.get$definition(), null))) {
     new MethodGenerator(meth, enclosingMethod).run();
   }
 }
 WorldGenerator.prototype._maybeIsTest = function(onType, checkType) {
-  if ($notnull_bool(!$notnull_bool(checkType.isTested))) return;
+  if (!$notnull_bool(checkType.isTested)) return;
   var value = 'false';
   if ($notnull_bool(onType.isSubtypeOf(checkType))) {
     value = 'function(){return this;}';
   }
   this.writer.writeln(('' + onType.get$jsname() + '.prototype.is\$' + checkType.get$jsname() + ' = ') + ('' + value + ';'));
 }
 WorldGenerator.prototype.writeType = function(type) {
   var $0;
-  if ($notnull_bool(type.name != null && (type instanceof ConcreteType)) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
+  if (type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
     this.writer.writeln(('' + type.get$jsname() + ' = ' + type.get$genericType().get$jsname() + ';'));
     return;
   }
-  var typeName = $notnull_bool(type.get$jsname() != null) ? type.get$jsname() : 'top level';
+  var typeName = type.get$jsname() != null ? type.get$jsname() : 'top level';
   this.writer.comment(('// ********** Code for ' + typeName + ' **************'));
   if ($notnull_bool(type.get$isNativeType() && !$notnull_bool(type.get$isTop()))) {
     var nativeName = type.get$definition().get$nativeType();
     if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
-    else if ($notnull_bool(type.get$jsname() != nativeName)) {
+    else if (type.get$jsname() != nativeName) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
   if ($notnull_bool(type.get$isTop())) {
   }
-  else if ($notnull_bool(type.get$constructors().get$length() == 0)) {
-    if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
+  else if (type.get$constructors().get$length() == 0) {
+    if (!$notnull_bool(type.get$isNativeType())) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
     var standardConstructor = (($0 = type.get$constructors().$index('')) && $0.is$Member());
-    if ($notnull_bool(standardConstructor == null || standardConstructor.generator == null)) {
-      if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
+    if (standardConstructor == null || standardConstructor.generator == null) {
+      if (!$notnull_bool(type.get$isNativeType())) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
     var $list = type.get$constructors().getValues();
     for (var $i = type.get$constructors().getValues().iterator(); $i.hasNext(); ) {
       var c = $i.next();
       if ($notnull_bool($ne(c.generator, null) && $ne(c, standardConstructor))) {
         c.generator.writeDefinition(this.writer, null);
       }
     }
   }
-  if ($notnull_bool(!$notnull_bool(type.get$isTop()))) {
-    if ($notnull_bool((type instanceof ConcreteType))) {
+  if (!$notnull_bool(type.get$isTop())) {
+    if ((type instanceof ConcreteType)) {
       this._ensureInheritsHelper();
       this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
     }
-    else if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
-      if ($notnull_bool(type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject()))) {
+    else if (!$notnull_bool(type.get$isNativeType())) {
+      if (type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject())) {
         this._ensureInheritsHelper();
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
-  if ($notnull_bool(!(type instanceof ConcreteType))) {
+  if (!(type instanceof ConcreteType)) {
     this._maybeIsTest(type, type);
   }
-  if ($notnull_bool(type.get$genericType()._concreteTypes != null)) {
+  if (type.get$genericType()._concreteTypes != null) {
     var $list = this._orderValues(type.get$genericType()._concreteTypes);
     for (var $i = 0;$i < $list.length; $i++) {
       var ct = $list.$index($i);
       this._maybeIsTest(type, (ct && ct.is$lang_Type()));
     }
   }
-  if ($notnull_bool(type.get$interfaces() != null)) {
+  if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
-    while ($notnull_bool(!$notnull_bool(worklist.isEmpty()))) {
+    while (!worklist.isEmpty()) {
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
-      if ($notnull_bool(interface_.get$genericType()._concreteTypes != null)) {
+      if (interface_.get$genericType()._concreteTypes != null) {
         var $list = this._orderValues(interface_.get$genericType()._concreteTypes);
         for (var $i = 0;$i < $list.length; $i++) {
           var ct = $list.$index($i);
           this._maybeIsTest(type, (ct && ct.is$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
       for (var $i = interface_.get$interfaces().iterator(); $i.hasNext(); ) {
         var other = $i.next();
-        if ($notnull_bool(!$notnull_bool(seen.contains(other)))) {
+        if (!seen.contains(other)) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
   type.get$factories().forEach(this.get$_writeMethod());
   var $list = this._orderValues(type.get$members());
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
-    if ($notnull_bool((member instanceof FieldMember))) {
+    if ((member instanceof FieldMember)) {
       this._writeField((member && member.is$FieldMember()));
     }
-    if ($notnull_bool((member instanceof PropertyMember))) {
+    if ((member instanceof PropertyMember)) {
       this._writeProperty((member && member.is$PropertyMember()));
     }
     if ($notnull_bool(member.get$isMethod())) {
       this._writeMethod((member && member.is$Member()));
     }
   }
   this._writeDynamicStubs(type);
 }
 WorldGenerator.prototype._ensureInheritsHelper = function() {
   if ($notnull_bool(this._inheritsGenerated)) return;
   this._inheritsGenerated = true;
   this.writer.writeln("/** Implements extends for Dart classes on JavaScript prototypes. */\nfunction $inherits(child, parent) {\n  if (child.prototype.__proto__) {\n    child.prototype.__proto__ = parent.prototype;\n  } else {\n    function tmp() {};\n    tmp.prototype = parent.prototype;\n    child.prototype = new tmp();\n    child.prototype.constructor = child;\n  }\n}");
 }
 WorldGenerator.prototype._writeDynamicStubs = function(type) {
-  if ($notnull_bool(type.varStubs != null)) {
+  if (type.varStubs != null) {
     var $list = orderValuesByKeys(type.varStubs);
     for (var $i = 0;$i < $list.length; $i++) {
       var stub = $list.$index($i);
       stub.generate(this.writer);
     }
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
   if ($notnull_bool(field.isFinal)) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
-  if ($notnull_bool(this.globals.containsKey(fullname))) {
+  if (this.globals.containsKey(fullname)) {
     var value = this.globals.$index(fullname);
     if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative))) {
       this.writer.writeln(('var ' + field.get$jsname() + ' = ' + value.exp.code + ';'));
     }
     else {
       this.writer.writeln(('' + field.declaringType.get$jsname() + '.' + field.get$jsname() + ' = ' + value.exp.code + ';'));
     }
   }
 }
 WorldGenerator.prototype._writeField = function(field) {
   if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative)) && field.value == null) {
     this.writer.writeln(('var ' + field.get$jsname() + ';'));
   }
   if ($notnull_bool(field._providePropertySyntax)) {
     this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.get\$' + field.get$jsname() + ' = ') + ('function() { return this.' + field.get$jsname() + '; };'));
-    if ($notnull_bool(!$notnull_bool(field.isFinal))) {
+    if (!$notnull_bool(field.isFinal)) {
       this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.set\$' + field.get$jsname() + ' = ') + ('function(value) { return this.' + field.get$jsname() + ' = value; };'));
     }
   }
 }
 WorldGenerator.prototype._writeProperty = function(property) {
-  if ($notnull_bool(property.getter != null)) this._writeMethod(property.getter);
-  if ($notnull_bool(property.setter != null)) this._writeMethod(property.setter);
+  if (property.getter != null) this._writeMethod(property.getter);
+  if (property.setter != null) this._writeMethod(property.setter);
   if ($notnull_bool(property._provideFieldSyntax)) {
     this.writer.enterBlock('Object.defineProperty(' + ('' + property.declaringType.get$jsname() + '.prototype, "' + property.get$jsname() + '", {'));
-    if ($notnull_bool(property.getter != null)) {
+    if (property.getter != null) {
       this.writer.write(('get: ' + property.declaringType.get$jsname() + '.prototype.' + property.getter.get$jsname() + ''));
-      this.writer.writeln($notnull_bool(property.setter == null) ? '' : ',');
+      this.writer.writeln(property.setter == null ? '' : ',');
     }
-    if ($notnull_bool(property.setter != null)) {
+    if (property.setter != null) {
       this.writer.writeln(('set: ' + property.declaringType.get$jsname() + '.prototype.' + property.setter.get$jsname() + ''));
     }
     this.writer.exitBlock('});');
   }
 }
 WorldGenerator.prototype._writeMethod = function(method) {
-  if ($notnull_bool(method.generator != null)) {
+  if (method.generator != null) {
     method.generator.writeDefinition(this.writer, null);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return WorldGenerator.prototype._writeMethod.bind(this);
 }
 WorldGenerator.prototype._writeGlobals = function() {
-  if ($notnull_bool(this.globals.get$length() > 0)) {
+  if (this.globals.get$length() > 0) {
     this.writer.comment('//  ********** Globals **************');
   }
   var list = this.globals.getValues();
   list.sort((function (a, b) {
     return a.compareTo(b);
   })
   );
   for (var $i = list.iterator(); $i.hasNext(); ) {
     var global = $i.next();
-    if ($notnull_bool(global.field != null)) {
+    if (global.field != null) {
       this._writeStaticField(global.field);
     }
     else {
       this.writer.writeln(('var ' + global.get$name() + ' = ' + global.exp.code + ';'));
     }
   }
 }
 WorldGenerator.prototype._orderValues = function(map) {
   var $0;
   var values = (($0 = map.getValues()) && $0.is$List());
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
-  if ($notnull_bool(x.get$span() != null && y.get$span() != null)) {
+  if (x.get$span() != null && y.get$span() != null) {
     var spans = x.get$span().compareTo(y.get$span());
-    if ($notnull_bool(spans != 0)) return spans;
+    if (spans != 0) return spans;
   }
-  if ($notnull_bool(x.get$span() == null)) return 1;
-  if ($notnull_bool(y.get$span() == null)) return -1;
+  if (x.get$span() == null) return 1;
+  if (y.get$span() == null) return -1;
   return x.get$name().compareTo(y.get$name());
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var $0;
   this.corejs.useMap = true;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember('\$setindex');
@@ skipping 13 matching lines @@
     this._closedOver = new HashSetImplementation$String();
   }
   else {
     this.reentrant = $notnull_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.is$BlockScope = function(){return this;};
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
-  return $notnull_bool(this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod));
+  return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
 }
 BlockScope.prototype.get$methodScope = function() {
   var s = this;
-  while ($notnull_bool(!$notnull_bool(s.get$isMethodScope()))) s = s.get$parent();
+  while (!$notnull_bool(s.get$isMethodScope())) s = s.get$parent();
   return (s && s.is$BlockScope());
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($notnull_bool($ne(ret, null))) return ret;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
     ret = s._vars.$index(name);
     if ($notnull_bool($ne(ret, null))) {
-      if ($notnull_bool($ne(s.enclosingMethod, this.enclosingMethod))) {
+      if ($ne(s.enclosingMethod, this.enclosingMethod)) {
         s.get$methodScope()._closedOver.add(ret.code);
         if ($notnull_bool(this.enclosingMethod.captures != null && s.reentrant)) {
           this.enclosingMethod.captures.add(ret.code);
         }
       }
       return ret;
     }
   }
 }
 BlockScope.prototype._isDefinedInParent = function(name) {
   if ($notnull_bool(this.get$isMethodScope() && this._closedOver.contains(name))) return true;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
-    if ($notnull_bool(s._vars.containsKey(name))) return true;
+    if (s._vars.containsKey(name)) return true;
     if ($notnull_bool(s.get$isMethodScope() && s._closedOver.contains(name))) return true;
   }
   var type = this.enclosingMethod.method.declaringType;
-  if ($notnull_bool(type.get$library().lookup(name, null) != null)) return true;
+  if (type.get$library().lookup(name, null) != null) return true;
   return false;
 }
 BlockScope.prototype.create = function(name, type, span, isParameter) {
   var jsName = world.toJsIdentifier(name);
-  if ($notnull_bool(this._vars.containsKey(name))) {
+  if (this._vars.containsKey(name)) {
     world.error(('duplicate name "' + name + '"'), span);
   }
-  if ($notnull_bool(!$notnull_bool(isParameter))) {
+  if (!$notnull_bool(isParameter)) {
     var index = 0;
     while ($notnull_bool(this._isDefinedInParent($assert_String(jsName)))) {
       jsName = ('' + name + '' + index++ + '');
     }
   }
   var ret = new Value(type, jsName, span, false);
   this._vars.$setindex(name, ret);
   return (ret && ret.is$Value());
 }
 BlockScope.prototype.declareParameter = function(p) {
@@ skipping 11 matching lines @@
   return scope.rethrow;
 }
 // ********** Code for MethodGenerator **************
 function MethodGenerator(method, enclosingMethod) {
   var $0;
   this.method = method;
   this.enclosingMethod = enclosingMethod;
   this.writer = new CodeWriter();
   this.needsThis = false;
   // Initializers done
-  if ($notnull_bool(this.enclosingMethod != null)) {
+  if (this.enclosingMethod != null) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
-  if ($notnull_bool(this.enclosingMethod != null && this.method.name != '')) {
+  if (this.enclosingMethod != null && this.method.name != '') {
     var m = (($0 = this.method) && $0.is$MethodMember());
     this._scope.create(m.name, m.get$functionType(), m.definition.span, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
 MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.get$library = function() {
   return this.method.get$library();
 }
 MethodGenerator.prototype.findMembers = function(name) {
   return this.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return $notnull_bool(value.needsTemp) ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
-  if ($notnull_bool(this._freeTemps.length > 0)) {
+  if (this._freeTemps.length > 0) {
     name = $assert_String(this._freeTemps.removeLast());
   }
   else {
     name = '\$' + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
   return new Value(value.type, name, value.span, false);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
-  if ($notnull_bool($eq(tmp, v))) {
+  if ($eq(tmp, v)) {
     return v;
   }
   else {
     return new Value(v.type, ('(' + tmp.code + ' = ' + v.code + ')'), v.span, true);
   }
 }
 MethodGenerator.prototype.freeTemp = function(value) {
-  if ($notnull_bool(this._usedTemps.remove(value.code))) {
+  if (this._usedTemps.remove(value.code)) {
     this._freeTemps.add(value.code);
   }
   else {
     world.internalError(('tried to free unused value or non-temp "' + value.code + '"'));
   }
 }
 MethodGenerator.prototype.run = function() {
   if ($notnull_bool(this.method.isGenerated)) return;
   this.method.isGenerated = true;
   this.method.generator = this;
-  if ($notnull_bool((this.method.get$definition().body instanceof NativeStatement))) {
+  if ((this.method.get$definition().body instanceof NativeStatement)) {
     if ($notnull_bool(this.method.get$definition().body.body == null)) {
       this.method.generator = null;
     }
     else {
       this._paramCode = map(this.method.get$parameters(), (function (p) {
         return p.get$name();
       })
       );
       this.writer.write($assert_String(this.method.get$definition().body.body));
     }
   }
   else {
     this.writeBody();
   }
 }
 MethodGenerator.prototype.writeDefinition = function(defWriter, lambda) {
   var $0;
   var paramCode = this._paramCode;
   var names = null;
-  if ($notnull_bool(this.captures != null && this.captures.get$length() > 0)) {
+  if (this.captures != null && this.captures.get$length() > 0) {
     names = ListFactory.ListFactory$from$factory(this.captures);
     names.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     paramCode = ListFactory.ListFactory$from$factory((names && names.is$Iterable()));
     paramCode.addAll(this._paramCode);
   }
   var _params = ('(' + Strings.join(this._paramCode, ", ") + ')');
   var params = ('(' + Strings.join((paramCode && paramCode.is$List$String()), ", ") + ')');
   if ($notnull_bool(this.method.declaringType.get$isTop() && !$notnull_bool(this.get$isClosure()))) {
     defWriter.enterBlock(('function ' + this.method.get$jsname() + '' + params + ' {'));
   }
   else if ($notnull_bool(this.get$isClosure())) {
-    if ($notnull_bool(this.method.name == '')) {
+    if (this.method.name == '') {
       defWriter.enterBlock(('(function ' + params + ' {'));
     }
     else if ($notnull_bool($ne(names, null))) {
-      if ($notnull_bool(lambda == null)) {
+      if (lambda == null) {
         defWriter.enterBlock(('var ' + this.method.get$jsname() + ' = (function' + params + ' {'));
       }
       else {
         defWriter.enterBlock(('(function ' + this.method.get$jsname() + '' + params + ' {'));
       }
     }
     else {
       defWriter.enterBlock(('function ' + this.method.get$jsname() + '' + params + ' {'));
     }
   }
   else if ($notnull_bool(this.method.get$isConstructor())) {
-    if ($notnull_bool(this.method.get$constructorName() == '')) {
+    if (this.method.get$constructorName() == '') {
       defWriter.enterBlock(('function ' + this.method.declaringType.get$jsname() + '' + params + ' {'));
     }
     else {
       defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$constructorName() + '\$ctor = function' + params + ' {'));
     }
   }
   else if ($notnull_bool(this.method.get$isFactory())) {
     defWriter.enterBlock(('' + this.method.get$generatedFactoryName() + ' = function' + _params + ' {'));
   }
   else if ($notnull_bool(this.method.get$isStatic())) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.') + ('' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
-  if ($notnull_bool(this._usedTemps.get$length() > 0 || this._freeTemps.length > 0)) {
+  if (this._usedTemps.get$length() > 0 || this._freeTemps.length > 0) {
     $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 695, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if ($notnull_bool($ne(names, null))) {
     defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
   }
   else if ($notnull_bool(this.get$isClosure() && this.method.name == '')) {
     defWriter.exitBlock('})');
   }
   else {
     defWriter.exitBlock('}');
   }
   if ($notnull_bool(this.method.get$isConstructor() && this.method.get$constructorName() != '')) {
     defWriter.writeln(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$constructorName() + '\$ctor.prototype = ') + ('' + this.method.declaringType.get$jsname() + '.prototype;'));
   }
   this._provideOptionalParamInfo(defWriter);
-  if ($notnull_bool((this.method instanceof MethodMember))) {
+  if ((this.method instanceof MethodMember)) {
     var m = (($0 = this.method) && $0.is$MethodMember());
     if ($notnull_bool(m._providePropertySyntax)) {
       defWriter.enterBlock(('' + m.declaringType.get$jsname() + '.prototype') + ('.get\$' + m.get$jsname() + ' = function() {'));
       defWriter.writeln(('return ' + m.declaringType.get$jsname() + '.prototype.') + ('' + m.get$jsname() + '.bind(this);'));
       defWriter.exitBlock('}');
       if ($notnull_bool(m._provideFieldSyntax)) {
         world.internalError('bound m accessed with field syntax');
       }
     }
   }
 }
 MethodGenerator.prototype._provideOptionalParamInfo = function(defWriter) {
   var $0;
-  if ($notnull_bool((this.method instanceof MethodMember))) {
+  if ((this.method instanceof MethodMember)) {
     var meth = (($0 = this.method) && $0.is$MethodMember());
     if ($notnull_bool(meth._provideOptionalParamInfo)) {
       var optNames = [];
       var optValues = [];
       meth.genParameterValues();
       var $list = meth.parameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var param = $list.$index($i);
         if ($notnull_bool(param.get$isOptional())) {
           optNames.add(param.get$name());
           optValues.add(MethodGenerator._escapeString(param.get$value().code));
         }
       }
-      if ($notnull_bool(optNames.length > 0)) {
+      if (optNames.length > 0) {
         var start = '';
         if ($notnull_bool(meth.isStatic)) {
-          if ($notnull_bool(!$notnull_bool(meth.declaringType.get$isTop()))) {
+          if (!$notnull_bool(meth.declaringType.get$isTop())) {
             start = meth.declaringType.get$jsname() + '.';
           }
         }
         else {
           start = meth.declaringType.get$jsname() + '.prototype.';
         }
         optNames.addAll(optValues);
         var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
         defWriter.writeln(('' + start + '' + meth.get$jsname() + '.\$optional = ' + optional + ''));
       }
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
   var $0;
   var initializers = null;
   var initializedFields = null;
   if ($notnull_bool(this.method.get$isConstructor())) {
     initializers = [];
     initializedFields = new HashSetImplementation();
     var $list = world.gen._orderValues(this.method.declaringType.getAllMembers());
     for (var $i = 0;$i < $list.length; $i++) {
       var f = $list.$index($i);
-      if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic()))) {
+      if ((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic())) {
         var cv = f.computeValue();
         if ($notnull_bool($ne(cv, null))) {
           initializers.add(('this.' + f.get$jsname() + ' = ' + cv.code + ''));
           initializedFields.add(f.get$name());
         }
       }
     }
   }
   this._paramCode = [];
   var $list = this.method.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     if ($notnull_bool($ne(initializers, null) && p.isInitializer)) {
       var field = this.method.declaringType.getMember(p.get$name());
       if ($notnull_bool(field == null)) {
         world.error('bad this parameter - no matching field', p.get$definition().get$span());
       }
-      if ($notnull_bool(!$notnull_bool(field.get$isField()))) {
+      if (!$notnull_bool(field.get$isField())) {
         world.error(('"this.' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
       var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false);
       this._paramCode.add(paramValue.code);
       initializers.add(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
       initializedFields.add(p.get$name());
     }
     else {
       var paramValue = this._scope.declareParameter((p && p.is$Parameter()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
   if ($notnull_bool(body == null && !$notnull_bool(this.method.get$isConstructor()))) {
     world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
   }
   if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator(); $i.hasNext(); ) {
       var i = $i.next();
       this.writer.writeln($assert_String(i));
     }
     var declaredInitializers = this.method.get$definition().initializers;
-    if ($notnull_bool(declaredInitializers != null)) {
+    if (declaredInitializers != null) {
       var initializerCall = null;
       for (var $i = 0;$i < declaredInitializers.length; $i++) {
         var init = declaredInitializers.$index($i);
-        if ($notnull_bool((init instanceof CallExpression))) {
+        if ((init instanceof CallExpression)) {
           if ($notnull_bool($ne(initializerCall, null))) {
             world.error('only one initializer redirecting call is allowed', init.get$span());
           }
           initializerCall = init;
         }
-        else if ($notnull_bool((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0)) {
+        else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0) {
           var left = init.x;
-          if ($notnull_bool(!$notnull_bool(($notnull_bool((left instanceof DotExpression) && (left.self instanceof ThisExpression)) || (left instanceof VarExpression))))) {
+          if (!((left instanceof DotExpression) && (left.self instanceof ThisExpression) || (left instanceof VarExpression))) {
             world.error('invalid left side of initializer', left.get$span());
             continue;
           }
           initializedFields.add(left.get$name().get$name());
           var assign = this._makeThisValue(null).set_(this, $assert_String(left.get$name().get$name()), (($0 = left.get$name()) && $0.is$lang_Node()), (($0 = this.visitValue(init.y)) && $0.is$Value()), false);
           this.writer.writeln(('' + assign.code + ';'));
         }
         else {
           world.error('invalid initializer', init.get$span());
         }
       }
       if ($notnull_bool($ne(initializerCall, null))) {
         var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
-        if ($notnull_bool(!$notnull_bool(target.isSuper))) {
-          if ($notnull_bool(initializers.length > 0)) {
+        if (!$notnull_bool(target.isSuper)) {
+          if (initializers.length > 0) {
             var $list = this.method.get$parameters();
             for (var $i = 0;$i < $list.length; $i++) {
               var p = $list.$index($i);
               if ($notnull_bool(p.isInitializer)) {
                 world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
                 break;
               }
             }
           }
-          if ($notnull_bool(declaredInitializers.length > 1)) {
+          if (declaredInitializers.length > 1) {
             var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
             world.error('no initialization allowed on redirecting constructors', init.get$span());
           }
           initializedFields = null;
         }
       }
       else {
       }
     }
     this.writer.comment('// Initializers done');
   }
   if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.get$members().getKeys();
     for (var $i = this.method.declaringType.get$members().getKeys().iterator(); $i.hasNext(); ) {
       var name = $i.next();
       var member = this.method.declaringType.get$members().$index(name);
-      if ($notnull_bool((member instanceof FieldMember) && member.isFinal) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains(name))) {
+      if ($notnull_bool((member instanceof FieldMember) && member.isFinal) && !$notnull_bool(member.get$isStatic()) && !initializedFields.contains(name)) {
         world.error(('Field "' + name + '" is final and was not initialized'), this.method.get$definition().get$span());
       }
     }
   }
   this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
-  if ($notnull_bool((targetExp instanceof DotExpression))) {
+  if ((targetExp instanceof DotExpression)) {
     var dot = (targetExp && targetExp.is$DotExpression());
     targetExp = dot.self;
     contructorName = dot.name.name;
   }
   var target = null;
-  if ($notnull_bool((targetExp instanceof SuperExpression))) {
+  if ((targetExp instanceof SuperExpression)) {
     target = this._makeSuperValue((targetExp && targetExp.is$lang_Node()));
   }
-  else if ($notnull_bool((targetExp instanceof ThisExpression))) {
+  else if ((targetExp instanceof ThisExpression)) {
     target = this._makeThisValue((targetExp && targetExp.is$lang_Node()));
   }
   else {
     world.error('bad call in initializers', node.span);
   }
   var m = target.type.getConstructor(contructorName);
   this.method.set$initDelegate(m);
   var other = m;
   while ($notnull_bool($ne(other, null))) {
     if ($notnull_bool($eq(other, this.method))) {
       world.error('initialization cycle', node.span);
       break;
     }
     other = other.get$initDelegate();
   }
   world.gen.genMethod((m && m.is$Member()));
   var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
   if ($notnull_bool($ne(target.type, world.objectType))) {
     this.writer.writeln(('' + value.code + ';'));
   }
   return (target && target.is$Value());
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var $0;
   var args = [];
   var seenLabel = false;
   for (var $i = 0;$i < arguments.length; $i++) {
     var arg = arguments.$index($i);
-    if ($notnull_bool(arg.label != null)) {
+    if (arg.label != null) {
       seenLabel = true;
     }
     else if ($notnull_bool(seenLabel)) {
       world.error('bare argument can not follow named arguments', arg.get$span());
     }
     args.add(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\n', '\\n').replaceAll('\r', '\\r');
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
-  if ($notnull_bool((body instanceof BlockStatement))) {
+  if ((body instanceof BlockStatement)) {
     var block = (body && body.is$BlockStatement());
     var $list = block.body;
     for (var $i = 0;$i < $list.length; $i++) {
       var stmt = $list.$index($i);
       stmt.visit(this);
     }
   }
   else {
-    if ($notnull_bool(body != null)) body.visit(this);
+    if (body != null) body.visit(this);
   }
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
   this._scope = new BlockScope(this, this._scope, reentrant);
 }
 MethodGenerator.prototype._popBlock = function() {
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._makeLambdaMethod = function(name, func) {
   var meth = new MethodMember(name, this.method.declaringType, func);
   meth.isLambda = true;
   meth.resolve(this.method.declaringType);
   world.gen.genMethod((meth && meth.is$Member()), this);
   return (meth && meth.is$MethodMember());
 }
 MethodGenerator.prototype.visitBool = function(node) {
-  return this.visitValue(node).convertToNonNullBool(this, node);
+  return this.visitValue(node).convertTo(this, world.nonNullBool, node, false);
 }
 MethodGenerator.prototype.visitValue = function(node) {
-  if ($notnull_bool(node == null)) return null;
+  if (node == null) return null;
   var value = node.visit(this);
   value.checkFirstClass(node.span);
   return value;
 }
 MethodGenerator.prototype.visitTypedValue = function(node, expectedType) {
   return this.visitValue(node).convertTo(this, expectedType, node, false);
 }
 MethodGenerator.prototype.visitVoid = function(node) {
-  if ($notnull_bool((node instanceof PostfixExpression))) {
+  if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression((node && node.is$PostfixExpression()), true);
     value.checkFirstClass(node.span);
     return value;
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
   var parser = new lang_Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var $0;
   var isFinal = false;
   if ($notnull_bool(node.modifiers != null && $eq(node.modifiers.$index(0).kind, 97/*TokenKind.FINAL*/))) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type, false);
   for (var i = 0;
-   $notnull_bool(i < node.names.length); i++) {
+   i < node.names.length; i++) {
     var thisType = type;
-    if ($notnull_bool(i > 0)) {
+    if (i > 0) {
       this.writer.write(', ');
     }
     var name = node.names.$index(i).get$name();
     var value = this.visitValue((($0 = node.values.$index(i)) && $0.is$lang_Expression()));
     if ($notnull_bool(isFinal)) {
       if ($notnull_bool(value == null)) {
         world.error('no value specified for final variable', node.span);
       }
       else {
         if ($notnull_bool(thisType.get$isVar())) thisType = value.type;
@@ skipping 13 matching lines @@
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var $0;
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod($assert_String(name), node);
   var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), this.method.get$definition().get$span(), false);
   meth.generator.writeDefinition(this.writer, null);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
-  if ($notnull_bool(node.value == null)) {
+  if (node.value == null) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
     }
     var value = this.visitTypedValue(node.value, this.method.get$returnType());
     this.writer.writeln(('return ' + value.code + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitThrowStatement = function(node) {
-  if ($notnull_bool(node.value != null)) {
+  if (node.value != null) {
     var value = this.visitValue(node.value);
     value.invoke$4(this, 'toString', node, Arguments.get$EMPTY());
     this.writer.writeln(('\$throw(' + value.code + ');'));
     world.gen.corejs.useThrow = true;
   }
   else {
     var rethrow = this._scope.getRethrow();
     if ($notnull_bool(rethrow == null)) {
       world.error('rethrow outside of catch', node.span);
     }
@@ skipping 12 matching lines @@
     world.gen.genMethod((($0 = err.get$members().$index('toString')) && $0.is$Member()));
     var span = node.test.span;
     var line = span.file.getLine(span.start);
     var column = span.file.getColumn($assert_num(line), span.start);
     this.writer.writeln(('\$assert(' + test.code + ', "' + MethodGenerator._escapeString(span.get$text()) + '",') + (' "' + basename(span.file.filename) + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
     world.gen.corejs.useAssert = true;
   }
   return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
-  if ($notnull_bool(node.label == null)) {
+  if (node.label == null) {
     this.writer.writeln('break;');
   }
   else {
     this.writer.writeln(('break ' + node.label.name + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitContinueStatement = function(node) {
-  if ($notnull_bool(node.label == null)) {
+  if (node.label == null) {
     this.writer.writeln('continue;');
   }
   else {
     this.writer.writeln(('continue ' + node.label.name + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitIfStatement = function(node) {
   var test = this.visitBool(node.test);
   this.writer.write(('if (' + test.code + ') '));
   var exit1 = node.trueBranch.visit(this);
-  if ($notnull_bool(node.falseBranch != null)) {
+  if (node.falseBranch != null) {
     this.writer.write('else ');
     if ($notnull_bool(node.falseBranch.visit(this) && exit1)) {
       return true;
     }
   }
   return false;
 }
 MethodGenerator.prototype.visitWhileStatement = function(node) {
   var test = this.visitBool(node.test);
   this.writer.write(('while (' + test.code + ') '));
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype.visitDoStatement = function(node) {
   this.writer.write('do ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   var test = this.visitBool(node.test);
   this.writer.writeln(('while (' + test.code + ')'));
   return false;
 }
 MethodGenerator.prototype.visitForStatement = function(node) {
   this._pushBlock(false);
   this.writer.write('for (');
-  if ($notnull_bool(node.init != null)) node.init.visit(this);
+  if (node.init != null) node.init.visit(this);
   else this.writer.write(';');
-  if ($notnull_bool(node.test != null)) {
+  if (node.test != null) {
     var test = this.visitBool(node.test);
     this.writer.write((' ' + test.code + '; '));
   }
   else {
     this.writer.write('; ');
   }
   var needsComma = false;
   var $list = node.step;
   for (var $i = 0;$i < $list.length; $i++) {
     var s = $list.$index($i);
@@ skipping 53 matching lines @@
   }
   this.writer.writeln(('' + ex + ' = \$toDartException(' + ex + ');'));
   world.gen.corejs.useToDartException = true;
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   var $0;
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
-  if ($notnull_bool(node.catches.length == 1)) {
+  if (node.catches.length == 1) {
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
     var ex = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
     this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
-    if ($notnull_bool(catch_.trace != null)) {
+    if (catch_.trace != null) {
       var trace = this._scope.declare(catch_.trace);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
       world.gen.corejs.useStackTraceOf = true;
     }
     this._genToDartException(ex.code, node);
-    if ($notnull_bool(!$notnull_bool(ex.type.get$isVar()))) {
+    if (!$notnull_bool(ex.type.get$isVar())) {
       var test = ex.instanceOf(this, (($0 = ex.type) && $0.is$lang_Type()), catch_.get$exception().get$span(), false, true);
       this.writer.writeln(('if (' + test.code + ') throw ' + ex.code + ';'));
     }
     this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$lang_Statement()));
     this._popBlock();
   }
-  else if ($notnull_bool(node.catches.length > 0)) {
+  else if (node.catches.length > 0) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', world.varType, null, false);
     this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
     var trace = null;
-    if ($notnull_bool(node.catches.some((function (c) {
+    if (node.catches.some((function (c) {
       return c.trace != null;
     })
-    ))) {
+    )) {
       trace = this._scope.create('\$trace', world.varType, null, false);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
       world.gen.corejs.useStackTraceOf = true;
     }
     this._genToDartException(ex.code, node);
     var needsRethrow = true;
     for (var i = 0;
-     $notnull_bool(i < node.catches.length); i++) {
+     i < node.catches.length; i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
       var tmp = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
-      if ($notnull_bool(!$notnull_bool(tmp.type.get$isVar()))) {
+      if (!$notnull_bool(tmp.type.get$isVar())) {
         var test = ex.instanceOf(this, (($0 = tmp.type) && $0.is$lang_Type()), catch_.get$exception().get$span(), true, true);
-        if ($notnull_bool(i == 0)) {
+        if (i == 0) {
           this.writer.enterBlock(('if (' + test.code + ') {'));
         }
         else {
           this.writer.nextBlock(('} else if (' + test.code + ') {'));
         }
       }
-      else if ($notnull_bool(i > 0)) {
+      else if (i > 0) {
         this.writer.nextBlock('} else {');
       }
       this.writer.writeln(('var ' + tmp.code + ' = ' + ex.code + ';'));
-      if ($notnull_bool(catch_.trace != null)) {
+      if (catch_.trace != null) {
         var tmptrace = this._scope.declare(catch_.trace);
         this.writer.writeln(('var ' + tmptrace.code + ' = ' + trace.code + ';'));
       }
       this.visitStatementsInBlock((($0 = catch_.body) && $0.is$lang_Statement()));
       this._popBlock();
       if ($notnull_bool(tmp.type.get$isVar())) {
-        if ($notnull_bool(i + 1 < node.catches.length)) {
+        if (i + 1 < node.catches.length) {
           world.warning('Unreachable catch clause', (($0 = node.catches.$index(i + 1)) && $0.is$SourceSpan()));
         }
-        if ($notnull_bool(i > 0)) {
+        if (i > 0) {
           this.writer.exitBlock('}');
         }
         needsRethrow = false;
         break;
       }
     }
     if ($notnull_bool(needsRethrow)) {
       this.writer.nextBlock('} else {');
       this.writer.writeln(('throw ' + ex.code + ';'));
       this.writer.exitBlock('}');
     }
     this._popBlock();
   }
-  if ($notnull_bool(node.finallyBlock != null)) {
+  if (node.finallyBlock != null) {
     this.writer.nextBlock('} finally {');
     this._pushBlock(false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
   var test = this.visitValue(node.test);
   this.writer.enterBlock(('switch (' + test.code + ') {'));
   var $list = node.cases;
   for (var $i = 0;$i < $list.length; $i++) {
     var case_ = $list.$index($i);
-    if ($notnull_bool(case_.label != null)) {
+    if (case_.label != null) {
       world.error('unimplemented: labeled case statement', case_.get$span());
     }
     this._pushBlock(false);
     for (var i = 0;
-     $notnull_bool(i < case_.cases.length); i++) {
+     i < case_.cases.length; i++) {
       var expr = case_.cases.$index(i);
       if ($notnull_bool(expr == null)) {
-        if ($notnull_bool(i < case_.cases.length - 1)) {
+        if (i < case_.cases.length - 1) {
           world.error('default clause must be the last case', case_.get$span());
         }
         this.writer.writeln('default:');
       }
       else {
         var value = this.visitValue((expr && expr.is$lang_Expression()));
         this.writer.writeln(('case ' + value.code + ':'));
       }
     }
     this.writer.enterBlock('');
     var caseExits = this._visitAllStatements(case_.statements, false);
     if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1)) && !$notnull_bool(caseExits))) {
       var span = case_.statements.$index(case_.statements.length - 1).get$span();
       this.writer.writeln('\$throw(new FallThroughError());');
       world.gen.corejs.useThrow = true;
     }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
   for (var i = 0;
-   $notnull_bool(i < statementList.length); i++) {
+   i < statementList.length; i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit(this);
     if ($notnull_bool($ne(stmt, statementList.$index(statementList.length - 1)) && exits)) {
       world.warning('unreachable code', statementList.$index(i + 1).get$span());
     }
   }
   return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock('}');
   this._popBlock();
   return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitLabeledStatement = function(node) {
   this.writer.writeln(('' + node.name.name + ':'));
   node.body.visit(this);
   return false;
 }
 MethodGenerator.prototype.visitExpressionStatement = function(node) {
-  if ($notnull_bool((node.body instanceof VarExpression) || (node.body instanceof ThisExpression))) {
+  if ((node.body instanceof VarExpression) || (node.body instanceof ThisExpression)) {
     world.warning('variable used as statement', node.span);
   }
   var value = this.visitVoid(node.body);
   this.writer.writeln(('' + value.code + ';'));
   return false;
 }
 MethodGenerator.prototype.visitEmptyStatement = function(node) {
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype._checkNonStatic = function(node) {
   if ($notnull_bool(this.get$isStatic())) {
     world.warning('not allowed in static method', node.span);
   }
 }
 MethodGenerator.prototype._makeSuperValue = function(node) {
   var parentType = this.method.declaringType.get$parent();
   this._checkNonStatic(node);
   if ($notnull_bool(parentType == null)) {
     world.error('no super class', node.span);
   }
   var ret = new Value(parentType, 'this', node.span, false);
   ret.isSuper = true;
   return ret;
 }
 MethodGenerator.prototype._getOutermostMethod = function() {
   var result = this;
-  while ($notnull_bool(result.enclosingMethod != null)) {
+  while (result.enclosingMethod != null) {
     result = result.enclosingMethod;
   }
   return result;
 }
 MethodGenerator.prototype._makeThisCode = function() {
-  if ($notnull_bool(this.enclosingMethod != null)) {
+  if (this.enclosingMethod != null) {
     this._getOutermostMethod().needsThis = true;
     return '\$this';
   }
   else {
     return 'this';
   }
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
-  if ($notnull_bool(this.enclosingMethod != null)) {
+  if (this.enclosingMethod != null) {
     var outermostMethod = this._getOutermostMethod();
     outermostMethod._checkNonStatic(node);
     outermostMethod.needsThis = true;
-    return new Value(outermostMethod.method.declaringType, '\$this', $notnull_bool(node != null) ? node.span : null, false);
+    return new Value(outermostMethod.method.declaringType, '\$this', node != null ? node.span : null, false);
   }
   else {
     this._checkNonStatic(node);
-    return new Value(this.method.declaringType, 'this', $notnull_bool(node != null) ? node.span : null, false);
+    return new Value(this.method.declaringType, 'this', node != null ? node.span : null, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = '';
-  if ($notnull_bool(node.func.name != null)) {
+  if (node.func.name != null) {
     name = world.toJsIdentifier(node.func.name.name);
   }
   var meth = this._makeLambdaMethod($assert_String(name), node.func);
   var w = new CodeWriter();
   meth.generator.writeDefinition((w && w.is$CodeWriter()), node);
   return new Value(meth.get$functionType(), w.get$text(), node.span, true);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
   var $0;
   var target;
   var position = node.target;
   var name = '\$call';
-  if ($notnull_bool((node.target instanceof DotExpression))) {
+  if ((node.target instanceof DotExpression)) {
     var dot = (($0 = node.target) && $0.is$DotExpression());
     target = dot.self.visit(this);
     name = dot.name.name;
     position = dot.name;
   }
-  else if ($notnull_bool((node.target instanceof VarExpression))) {
+  else if ((node.target instanceof VarExpression)) {
     var varExpr = (($0 = node.target) && $0.is$VarExpression());
     name = varExpr.name.name;
     target = this._scope.lookup($assert_String(name));
     if ($notnull_bool($ne(target, null))) {
       return target.invoke$4(this, '\$call', node, this._makeArgs(node.arguments));
     }
     target = this._makeThisOrType(varExpr.span);
     return target.invoke$4(this, name, node, this._makeArgs(node.arguments));
   }
   else {
     target = node.target.visit(this);
   }
   return target.invoke$4(this, name, position, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitIndexExpression = function(node) {
   var target = this.visitValue(node.target);
   var index = this.visitValue(node.index);
   return target.invoke$4(this, '\$index', node, new Arguments(null, [index]));
 }
 MethodGenerator.prototype.visitBinaryExpression = function(node) {
   var $0;
   var kind = node.op.kind;
-  if ($notnull_bool(kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/)) {
+  if (kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var code = ('' + x.code + ' ' + node.op + ' ' + y.code + '');
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
-      var value = $notnull_bool((kind == 35/*TokenKind.AND*/)) ? $notnull_bool(x.get$actualValue() && y.get$actualValue()) : $notnull_bool(x.get$actualValue() || y.get$actualValue());
+      var value = (kind == 35/*TokenKind.AND*/) ? $notnull_bool(x.get$actualValue() && y.get$actualValue()) : $notnull_bool(x.get$actualValue() || y.get$actualValue());
       return EvaluatedValue.EvaluatedValue$factory((($0 = x.type) && $0.is$lang_Type()), value, ('' + value + ''), node.span);
     }
     var ret = new Value(lang_Type.union((($0 = x.type) && $0.is$lang_Type()), (($0 = y.type) && $0.is$lang_Type())), code, node.span, true);
-    return ret.convertToNonNullBool(this, node);
+    return ret.convertTo(this, world.nonNullBool, node, false);
   }
-  else if ($notnull_bool(kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/)) {
+  else if (kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
-      var value = $notnull_bool(kind == 50/*TokenKind.EQ_STRICT*/) ? $eq(x.get$actualValue(), y.get$actualValue()) : $ne(x.get$actualValue(), y.get$actualValue());
-      return EvaluatedValue.EvaluatedValue$factory(world.boolType, value, ("" + value + ""), node.span);
+      var value = kind == 50/*TokenKind.EQ_STRICT*/ ? $eq(x.get$actualValue(), y.get$actualValue()) : $ne(x.get$actualValue(), y.get$actualValue());
+      return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, value, ("" + value + ""), node.span);
     }
-    if ($notnull_bool(x.code == 'null' || y.code == 'null')) {
+    if (x.code == 'null' || y.code == 'null') {
       var op = node.op.toString().substring(0, 2);
-      return new Value(world.boolType, ('' + x.code + ' ' + op + ' ' + y.code + ''), node.span, true);
+      return new Value(world.nonNullBool, ('' + x.code + ' ' + op + ' ' + y.code + ''), node.span, true);
     }
     else {
-      return new Value(world.boolType, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), node.span, true);
+      return new Value(world.nonNullBool, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), node.span, true);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
-  if ($notnull_bool(assignKind == -1)) {
+  if (assignKind == -1) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var name = TokenKind.binaryMethodName(node.op.kind);
-    if ($notnull_bool(node.op.kind == 49/*TokenKind.NE*/)) {
+    if (node.op.kind == 49/*TokenKind.NE*/) {
       name = '\$ne';
     }
     if ($notnull_bool(name == null)) {
       world.internalError(('unimplemented binary op ' + node.op + ''), node.span);
       return;
     }
     return x.invoke$4(this, name, node, new Arguments(null, [y]));
   }
   else {
     return this._visitAssign(assignKind, node.x, node.y, node, to$call$1(null));
   }
 }
 MethodGenerator.prototype._visitAssign = function(kind, xn, yn, position, captureOriginal) {
-  if ($notnull_bool(captureOriginal == null)) {
+  if (captureOriginal == null) {
     captureOriginal = (function (x) {
       return x;
     })
     ;
   }
-  if ($notnull_bool((xn instanceof VarExpression))) {
+  if ((xn instanceof VarExpression)) {
     return this._visitVarAssign(kind, (xn && xn.is$VarExpression()), yn, position, captureOriginal);
   }
-  else if ($notnull_bool((xn instanceof IndexExpression))) {
+  else if ((xn instanceof IndexExpression)) {
     return this._visitIndexAssign(kind, (xn && xn.is$IndexExpression()), yn, position, captureOriginal);
   }
-  else if ($notnull_bool((xn instanceof DotExpression))) {
+  else if ((xn instanceof DotExpression)) {
     return this._visitDotAssign(kind, (xn && xn.is$DotExpression()), yn, position, captureOriginal);
   }
   else {
     world.error('illegal lhs', position.span);
   }
 }
 MethodGenerator.prototype._visitVarAssign = function(kind, xn, yn, position, captureOriginal) {
   var $0;
   var name = xn.name.name;
   var x = this._scope.lookup(name);
   var y = this.visitValue(yn);
   if ($notnull_bool(x == null)) {
     var members = this.method.declaringType.resolveMember(name);
     if ($notnull_bool($ne(members, null))) {
       x = this._makeThisOrType(position.span);
-      if ($notnull_bool(kind == 0)) {
+      if (kind == 0) {
         return x.set_(this, name, position, (y && y.is$Value()), false);
       }
       else if ($notnull_bool(!$notnull_bool(members.get$treatAsField()) || members.get$containsMethods())) {
         var right = x.get_(this, name, position);
         right = captureOriginal((right && right.is$Value()));
         y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
         return x.set_(this, name, position, (y && y.is$Value()), false);
       }
       else {
         x = x.get_(this, name, position);
       }
     }
     else {
       var member = this.get$library().lookup(name, xn.name.span);
-      if ($notnull_bool(member == null)) {
+      if (member == null) {
         world.warning(('can not resolve ' + name + ''), xn.span);
         return this._makeMissingValue(name);
       }
       members = new MemberSet(member);
       if ($notnull_bool(!$notnull_bool(members.get$treatAsField()) || members.get$containsMethods())) {
-        if ($notnull_bool(kind != 0)) {
+        if (kind != 0) {
           var right = members._get$3(this, position, x);
           right = captureOriginal((right && right.is$Value()));
           y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
         }
         return members._set$4(this, position, x, y);
       }
       else {
         x = members._get$3(this, position, x);
       }
     }
   }
   y = y.convertTo(this, (($0 = x.type) && $0.is$lang_Type()), yn, false);
-  if ($notnull_bool(kind == 0)) {
+  if (kind == 0) {
     x = captureOriginal((x && x.is$Value()));
     return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
   }
   else if ($notnull_bool(x.type.get$isNum() && y.type.get$isNum()) && (kind != 46/*TokenKind.TRUNCDIV*/)) {
     x = captureOriginal((x && x.is$Value()));
     var op = TokenKind.kindToString(kind);
     return new Value(y.type, ('' + x.code + ' ' + op + '= ' + y.code + ''), position.span, true);
   }
   else {
     var right = x;
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
     return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
   }
 }
 MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
-  if ($notnull_bool(kind != 0)) {
+  if (kind != 0) {
     tmptarget = this.getTemp((target && target.is$Value()));
     tmpindex = this.getTemp((index && index.is$Value()));
     index = this.assignTemp((tmpindex && tmpindex.is$Value()), (index && index.is$Value()));
     var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [tmpindex]));
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
   var ret = this.assignTemp((tmptarget && tmptarget.is$Value()), (target && target.is$Value())).invoke(this, '\$setindex', position, new Arguments(null, [index, y]), false);
   if ($notnull_bool($ne(tmptarget, target))) this.freeTemp((tmptarget && tmptarget.is$Value()));
   if ($notnull_bool($ne(tmpindex, index))) this.freeTemp((tmpindex && tmpindex.is$Value()));
   return ret;
 }
 MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = xn.self.visit(this);
   var y = this.visitValue(yn);
   var tmptarget = target;
-  if ($notnull_bool(kind != 0)) {
+  if (kind != 0) {
     tmptarget = this.getTemp((target && target.is$Value()));
     var right = tmptarget.get_(this, xn.name.name, xn.name);
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
   var ret = this.assignTemp((tmptarget && tmptarget.is$Value()), (target && target.is$Value())).set_(this, xn.name.name, xn.name, (y && y.is$Value()), false);
   if ($notnull_bool($ne(tmptarget, target))) this.freeTemp((tmptarget && tmptarget.is$Value()));
   return ret;
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var $0;
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       if ($notnull_bool(value.type.get$isNum())) {
         return new Value(value.type, ('' + node.op + '' + value.code + ''), node.span, true);
       }
       else {
-        var kind = ($notnull_bool(16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
+        var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
         var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
         return this._visitAssign($assert_num(kind), node.self, (operand && operand.is$lang_Expression()), node, to$call$1(null));
       }
 
     case 19/*TokenKind.NOT*/:
 
       if ($notnull_bool(value.type.get$isBool() && value.get$isConst())) {
         var newVal = !$notnull_bool(value.get$actualValue());
         return EvaluatedValue.EvaluatedValue$factory((($0 = value.type) && $0.is$lang_Type()), newVal, ('' + newVal + ''), node.span);
       }
       else {
-        var newVal = value.convertToNonNullBool(this, node);
-        return new Value(world.boolType, ('!' + newVal.code + ''), node.span, true);
+        var newVal = value.convertTo(this, world.nonNullBool, node, false);
+        return new Value(newVal.type, ('!' + newVal.code + ''), node.span, true);
       }
 
     case 42/*TokenKind.ADD*/:
 
       return value.convertTo(this, world.numType, node, false);
 
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
-      if ($notnull_bool(node.op.kind == 18/*TokenKind.BIT_NOT*/)) {
+      if (node.op.kind == 18/*TokenKind.BIT_NOT*/) {
         return value.invoke$4(this, '\$bit_not', node, Arguments.get$EMPTY());
       }
-      else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) {
+      else if (node.op.kind == 43/*TokenKind.SUB*/) {
         return value.invoke$4(this, '\$negate', node, Arguments.get$EMPTY());
       }
       else {
         world.internalError(('unimplemented: unary ' + node.op + ''), node.span);
       }
       $throw(new FallThroughError());
 
     default:
 
       world.internalError(('unimplemented: ' + node.op + ''), node.span);
 
   }
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
   if ($notnull_bool(value.type.get$isNum())) {
     return new Value(value.type, ('' + value.code + '' + node.op + ''), node.span, true);
   }
-  var kind = $notnull_bool((16/*TokenKind.INCR*/ == node.op.kind)) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
+  var kind = (16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
   var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
   var tmpleft = null, left = null;
   var ret = this._visitAssign($assert_num(kind), node.body, (operand && operand.is$lang_Expression()), node, (function (l) {
     if ($notnull_bool(isVoid)) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp((l && l.is$Value()));
       return $this.assignTemp((tmpleft && tmpleft.is$Value()), (left && left.is$Value()));
     }
   })
   );
   if ($notnull_bool($ne(tmpleft, null))) {
     ret = new Value(ret.type, ("(" + ret.code + ", " + tmpleft.code + ")"), node.span, true);
   }
   if ($notnull_bool($ne(tmpleft, left))) {
     this.freeTemp((tmpleft && tmpleft.is$Value()));
   }
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var $0;
   var typeRef = node.type;
   var constructorName = '';
-  if ($notnull_bool(node.name != null)) {
+  if (node.name != null) {
     constructorName = node.name.name;
   }
   if ($notnull_bool($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference)) && typeRef.names != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.names);
     constructorName = names.removeLast().get$name();
-    if ($notnull_bool(names.length == 0)) names = null;
+    if (names.length == 0) names = null;
     typeRef = new NameTypeReference(typeRef.isFinal, typeRef.get$name(), names, typeRef.get$span());
   }
   var type = this.method.resolveType(typeRef, true);
   if ($notnull_bool(type.get$isTop())) {
     type = type.get$library().findTypeByName($assert_String(constructorName));
     constructorName = '';
   }
   var m = type.getConstructor(constructorName);
   if ($notnull_bool(m == null)) {
     var name = type.get$jsname();
     if ($notnull_bool(type.get$isVar())) {
       name = typeRef.get$name().get$name();
     }
     world.error(('no matching constructor for ' + name + ''), node.span);
     return this._makeMissingValue($assert_String(name));
   }
   if ($notnull_bool(node.isConst)) {
-    if ($notnull_bool(!$notnull_bool(m.get$isConst()))) {
+    if (!$notnull_bool(m.get$isConst())) {
       world.error('can\'t use const on a non-const constructor', node.span);
     }
     var $list = node.arguments;
     for (var $i = 0;$i < $list.length; $i++) {
       var arg = $list.$index($i);
-      if ($notnull_bool(!$notnull_bool(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())).get$isConst()))) {
+      if (!$notnull_bool(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())).get$isConst())) {
         world.error('const constructor expects const arguments', arg.get$span());
       }
     }
   }
   return m.invoke$4(this, node, null, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argsCode = [];
   var argValues = [];
   var $list = node.values;
   for (var $i = 0;$i < $list.length; $i++) {
     var item = $list.$index($i);
     var arg = this.visitValue((item && item.is$lang_Expression()));
     argValues.add(arg);
     if ($notnull_bool(node.isConst)) {
-      if ($notnull_bool(!$notnull_bool(arg.get$isConst()))) {
+      if (!$notnull_bool(arg.get$isConst())) {
         world.error('const list can only contain const values', item.get$span());
         argsCode.add(arg.code);
       }
       else {
         argsCode.add(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add(arg.code);
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed();
   var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var value = new Value(world.listType, code, node.span, true);
   if ($notnull_bool(node.isConst)) {
     var immutableList = world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor('from');
     var result = immutableListCtor.invoke$4(this, node, null, new Arguments(null, [value]));
     value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), result.code, node.span), (argValues && argValues.is$List$Value()));
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   var $0;
   var mapImplType = world.gen.useMapFactory();
   var argValues = [];
   var argsCode = [];
   for (var i = 0;
-   $notnull_bool(i < node.items.length); i += 2) {
+   i < node.items.length; i += 2) {
     var key = this.visitTypedValue((($0 = node.items.$index(i)) && $0.is$lang_Expression()), world.stringType);
     var valueItem = node.items.$index(i + 1);
     var value = this.visitValue((valueItem && valueItem.is$lang_Expression()));
     argValues.add(key);
     argValues.add(value);
     if ($notnull_bool(node.isConst)) {
-      if ($notnull_bool(!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst()))) {
+      if (!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst())) {
         world.error('const map can only contain const values', valueItem.get$span());
         argsCode.add(key.code);
         argsCode.add(value.code);
       }
       else {
         argsCode.add(key.get$canonicalCode());
         argsCode.add(value.get$canonicalCode());
       }
     }
     else {
@@ skipping 56 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(world.varType, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2073, 12);
-  if ($notnull_bool(!!(($0 = node.value) && $0.is$List))) {
+  $assert($ne(type, null), "type != null", "gen.dart", 2075, 12);
+  if (!!(($0 = node.value) && $0.is$List)) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
-      if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
+      if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression)) {
         code = ('(' + code + ')');
       }
       items.add(code);
     }
     return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if ($notnull_bool(type.get$isString())) {
-    if ($notnull_bool(text.startsWith('@'))) {
+    if (text.startsWith('@')) {
       text = MethodGenerator._escapeString(parseStringLiteral($assert_String(text)));
       text = ('"' + text + '"');
     }
     else if ($notnull_bool(isMultilineString($assert_String(text)))) {
       text = parseStringLiteral($assert_String(text));
       text = text.replaceAll('\n', '\\n');
       text = text.replaceAll('"', '\\"');
       text = ('"' + text + '"');
     }
-    if ($notnull_bool(text !== node.text)) {
+    if (text !== node.text) {
       node.value = text;
       node.text = $assert_String(text);
     }
   }
   return EvaluatedValue.EvaluatedValue$factory((type && type.is$lang_Type()), node.value, node.text, null);
 }
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression(($0 && $0.is$PostfixExpression()), false);
 }
 ;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
   // Initializers done
 }
 Arguments.prototype.is$Arguments = function(){return this;};
 Arguments.Arguments$bare$factory = function(arity) {
   var values = [];
   for (var i = 0;
-   $notnull_bool(i < arity); i++) {
+   i < arity; i++) {
     values.add(new Value(world.varType, ('\$' + i + ''), null, false));
   }
   return new Arguments(null, values);
 }
 Arguments.get$EMPTY = function() {
-  if ($notnull_bool(Arguments._empty == null)) {
+  if (Arguments._empty == null) {
     Arguments._empty = new Arguments(null, []);
   }
   return Arguments._empty;
 }
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
 Arguments.prototype.get$hasNames = function() {
   return this.get$bareCount() < this.get$length();
 }
 Arguments.prototype.get$length = function() {
   return this.values.length;
 }
 Object.defineProperty(Arguments.prototype, "length", {
   get: Arguments.prototype.get$length
 });
 Arguments.prototype.getName = function(i) {
   return this.nodes.$index(i).label.name;
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
-   $notnull_bool(i < this.get$length()); i++) {
-    if ($notnull_bool(this.getName(i) == name)) {
+   i < this.get$length(); i++) {
+    if (this.getName(i) == name) {
       return i;
     }
   }
   return -1;
 }
 Arguments.prototype.getValue = function(name) {
   var $0;
   var i = this.getIndexOfName(name);
-  return (($0 = $notnull_bool(i >= 0) ? this.values.$index(i) : null) && $0.is$Value());
+  return (($0 = i >= 0 ? this.values.$index(i) : null) && $0.is$Value());
 }
 Arguments.prototype.get$bareCount = function() {
-  if ($notnull_bool(this._bareCount == null)) {
+  if (this._bareCount == null) {
     this._bareCount = this.get$length();
-    if ($notnull_bool(this.nodes != null)) {
+    if (this.nodes != null) {
       for (var i = 0;
-       $notnull_bool(i < this.nodes.length); i++) {
-        if ($notnull_bool(this.nodes.$index(i).label != null)) {
+       i < this.nodes.length; i++) {
+        if (this.nodes.$index(i).label != null) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = 0;
-   $notnull_bool(i < this.get$length()); i++) {
+   i < this.get$length(); i++) {
     argsCode.add(this.values.$index(i).code);
   }
   Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
   return Strings.join((argsCode && argsCode.is$List$String()), ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
   while ($notnull_bool(argsCode.length > 0 && $eq(argsCode.last(), 'null'))) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
-   $notnull_bool(i < this.get$length()); i++) {
+   i < this.get$length(); i++) {
     names.add(this.getName(i));
   }
   return (names && names.is$List$String());
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = 0;
-   $notnull_bool(i < this.get$bareCount()); i++) {
+   i < this.get$bareCount(); i++) {
     result.add(new Value(world.varType, ('\$' + i + ''), null, false));
   }
   for (var i = this.get$bareCount();
-   $notnull_bool(i < this.get$length()); i++) {
+   i < this.get$length(); i++) {
     var name = this.getName(i);
     if ($notnull_bool(name == null)) name = ('\$' + i + '');
     result.add(new Value(world.varType, name, null, false));
   }
   return new Arguments(this.nodes, result);
 }
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix) {
   this.library = library;
   this.prefix = prefix;
@@ skipping 17 matching lines @@
 Library.prototype.is$Library = function(){return this;};
 Library.prototype.get$name = function() { return this.name; };
 Library.prototype.set$name = function(value) { return this.name = value; };
 Library.prototype.get$isCore = function() {
   return $eq(this, world.corelib);
 }
 Library.prototype.get$isCoreImpl = function() {
   return $eq(this, world.get$coreimpl());
 }
 Library.prototype.get$jsname = function() {
-  if ($notnull_bool(this._jsname == null)) {
+  if (this._jsname == null) {
     this._jsname = this.name.replaceAll('.', '_').replaceAll(':', '_').replaceAll(' ', '_');
   }
   return this._jsname;
 }
 Library.prototype.get$span = function() {
   return new SourceSpan(this.baseSource, 0, 0);
 }
 Library.prototype.makeFullPath = function(filename) {
-  if ($notnull_bool(filename.startsWith('dart:'))) return filename;
-  if ($notnull_bool(filename.startsWith('/'))) return filename;
-  if ($notnull_bool(filename.startsWith('file:///'))) return filename;
-  if ($notnull_bool(filename.startsWith('http://'))) return filename;
+  if (filename.startsWith('dart:')) return filename;
+  if (filename.startsWith('/')) return filename;
+  if (filename.startsWith('file:///')) return filename;
+  if (filename.startsWith('http://')) return filename;
   return joinPaths(this.sourceDir, filename);
 }
 Library.prototype.addImport = function(fullname, prefix) {
   var newLib = world.getOrAddLibrary(fullname);
   this.imports.add(new LibraryImport(newLib, prefix));
   return newLib;
 }
 Library.prototype.addNative = function(fullname) {
   this.natives.add(world.reader.readFile(fullname));
 }
 Library.prototype._findMembers = function(name) {
   var $0;
-  if ($notnull_bool(name.startsWith('_'))) {
+  if (name.startsWith('_')) {
     return (($0 = this._privateMembers.$index(name)) && $0.is$MemberSet());
   }
   else {
     return (($0 = world._members.$index(name)) && $0.is$MemberSet());
   }
 }
 Library.prototype._addMember = function(member) {
   if ($notnull_bool(member.get$isPrivate())) {
     if ($notnull_bool(member.get$isStatic())) {
       if ($notnull_bool(member.declaringType.get$isTop())) {
         world._addTopName(member);
       }
       return;
     }
     var mset = this._privateMembers.$index(member.name);
     if ($notnull_bool(mset == null)) {
       var $list = world.libraries.getValues();
       for (var $i = world.libraries.getValues().iterator(); $i.hasNext(); ) {
         var lib = $i.next();
-        if ($notnull_bool(lib._privateMembers.containsKey(member.name))) {
+        if (lib._privateMembers.containsKey(member.name)) {
           member.set$jsname(('_' + this.get$jsname() + '' + member.name + ''));
           break;
         }
       }
       mset = new MemberSet(member);
       this._privateMembers.$setindex(member.name, mset);
     }
     else {
       mset.get$members().add(member);
     }
   }
   else {
     world._addMember(member);
   }
 }
 Library.prototype.getOrAddFunctionType = function(name, func, inType) {
   var def = new FunctionTypeDefinition(func, null, func.span);
   var type = new DefinedType(name, this, def, false);
   type.addMethod('\$call', func);
   type.members.$index('\$call').resolve(inType);
   type.interfaces = [world.functionType];
   return type;
 }
 Library.prototype.addType = function(name, definition, isClass) {
   var $0;
-  if ($notnull_bool(this.types.containsKey(name))) {
+  if (this.types.containsKey(name)) {
     var existingType = this.types.$index(name);
     if ($notnull_bool(this.get$isCore() && existingType.get$definition() == null)) {
       existingType.setDefinition((definition && definition.is$Definition()));
     }
     else {
       world.warning(('duplicate definition of ' + name + ''), definition.span);
     }
   }
   else {
     this.types.$setindex(name, new DefinedType(name, this, (definition && definition.is$Definition()), isClass));
   }
   return (($0 = this.types.$index(name)) && $0.is$DefinedType());
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
-  if ($notnull_bool(result == null)) return null;
-  if ($notnull_bool(type.names != null)) {
-    if ($notnull_bool(type.names.length > 1)) {
+  if (result == null) return null;
+  if (type.names != null) {
+    if (type.names.length > 1) {
       return null;
     }
-    if ($notnull_bool(!$notnull_bool(result.get$isTop()))) {
+    if (!$notnull_bool(result.get$isTop())) {
       return null;
     }
     return result.get$library().findTypeByName($assert_String(type.names.$index(0).get$name()));
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name) {
   var ret = this.types.$index(name);
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
     var newRet = null;
-    if ($notnull_bool(imported.prefix == null)) {
+    if (imported.prefix == null) {
       newRet = imported.get$library().types.$index(name);
     }
-    else if ($notnull_bool(imported.prefix == name)) {
+    else if (imported.prefix == name) {
       newRet = imported.get$library().topType;
     }
     if ($notnull_bool($ne(newRet, null))) {
       if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
         world.error(('conflicting types for "' + name + '"'), ret.get$span(), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
@@ skipping 11 matching lines @@
     if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
       world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
     }
     else {
       ret = newRet;
     }
   }
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
-    if ($notnull_bool(imported.prefix == null)) {
+    if (imported.prefix == null) {
       newRet = imported.get$library().topType.getMember(name);
       if ($notnull_bool($ne(newRet, null))) {
         if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
           world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   return (ret && ret.is$Member());
 }
 Library.prototype.resolve = function() {
-  if ($notnull_bool(this.name == null)) {
+  if (this.name == null) {
     this.name = this.baseSource.filename;
     var index = this.name.lastIndexOf('/', this.name.length);
-    if ($notnull_bool(index >= 0)) {
+    if (index >= 0) {
       this.name = this.name.substring(index + 1);
     }
     index = this.name.indexOf('.', 0);
-    if ($notnull_bool(index > 0)) {
+    if (index > 0) {
       this.name = this.name.substring(0, index);
     }
   }
   var $list = this.types.getValues();
   for (var $i = this.types.getValues().iterator(); $i.hasNext(); ) {
     var type = $i.next();
     type.resolve();
   }
 }
 Library.prototype.visitSources = function() {
@@ skipping 16 matching lines @@
 }
 _LibraryVisitor.prototype.get$library = function() { return this.library; };
 _LibraryVisitor.prototype.get$isTop = function() { return this.isTop; };
 _LibraryVisitor.prototype.set$isTop = function(value) { return this.isTop = value; };
 _LibraryVisitor.prototype.addSourceFromName = function(name, span) {
   var filename = this.library.makeFullPath(name);
   if ($notnull_bool($eq(filename, this.library.baseSource.filename))) {
     world.error('library can not source itself', span);
     return;
   }
-  else if ($notnull_bool(this.sources.some((function (s) {
+  else if (this.sources.some((function (s) {
     return s.filename == filename;
   })
-  ))) {
+  )) {
     world.error(('file "' + filename + '" has already been sourced'), span);
     return;
   }
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 _LibraryVisitor.prototype.addSource = function(source) {
   var $this = this; // closure support
-  if ($notnull_bool(this.library.sources.some((function (s) {
+  if (this.library.sources.some((function (s) {
     return s.filename == source.filename;
   })
-  ))) {
+  )) {
     world.error(('duplicate source file "' + source.filename + '"'));
     return;
   }
   this.library.sources.add(source);
   var parser = new lang_Parser(source, options.dietParse, false, false, 0);
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit($this);
   })
   );
   $assert($notnull_bool(this.sources.length == 0 || this.isTop), "sources.length == 0 || isTop", "library.dart", 293, 12);
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource((source0 && source0.is$SourceFile()));
   }
 }
 _LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
-  if ($notnull_bool(!$notnull_bool(this.isTop))) {
+  if (!$notnull_bool(this.isTop)) {
     world.error('directives not allowed in sourced file', node.span);
     return;
   }
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
-      if ($notnull_bool(this.library.name == null)) {
+      if (this.library.name == null) {
         this.library.name = $assert_String(name);
         if ($notnull_bool($eq(name, 'node') || $eq(name, 'dom'))) {
           this.library.topType.isNativeType = true;
         }
-        if ($notnull_bool(this.seenImport || this.seenSource) || this.seenResource) {
+        if ($notnull_bool($notnull_bool(this.seenImport || this.seenSource) || this.seenResource)) {
           world.error('#library must be first directive in file', node.span);
         }
       }
       else {
         world.error('already specified library name', node.span);
       }
       break;
 
     case "import":
 
       this.seenImport = true;
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
-      if ($notnull_bool(node.arguments.length > 2 || $notnull_bool(node.arguments.length == 2 && prefix == null))) {
+      if (node.arguments.length > 2 || $notnull_bool(node.arguments.length == 2 && prefix == null)) {
         world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.length + ''), node.span);
       }
       else if ($notnull_bool($ne(prefix, null) && prefix.indexOf('.', 0) >= 0)) {
         world.error('library prefix canot contain "."', node.span);
       }
       else if ($notnull_bool(this.seenSource || this.seenResource)) {
         world.error('#imports must come before any #source or #resource', node.span);
       }
       if ($notnull_bool($eq(prefix, ''))) prefix = null;
       var filename = this.library.makeFullPath($assert_String(name));
-      if ($notnull_bool(this.library.imports.some((function (li) {
+      if (this.library.imports.some((function (li) {
         return $eq(li.get$library().baseSource, filename);
       })
-      ))) {
+      )) {
         world.error(('duplicate import of "' + name + '"'), node.span);
         return;
       }
       var newLib = this.library.addImport($assert_String(filename), $assert_String(prefix));
       break;
 
     case "source":
 
       this.seenSource = true;
       name = this.getSingleStringArg(node);
@@ skipping 15 matching lines @@
       this.getFirstStringArg(node);
       break;
 
     default:
 
       world.error(('unknown directive: ' + node.name.name + ''), node.span);
 
   }
 }
 _LibraryVisitor.prototype.getSingleStringArg = function(node) {
-  if ($notnull_bool(node.arguments.length != 1)) {
+  if (node.arguments.length != 1) {
     world.error(('expected exactly one argument but found ' + node.arguments.length + ''), node.span);
   }
   return this.getFirstStringArg(node);
 }
 _LibraryVisitor.prototype.getFirstStringArg = function(node) {
-  if ($notnull_bool(node.arguments.length < 1)) {
+  if (node.arguments.length < 1) {
     world.error(('expected at least one argument but found ' + node.arguments.length + ''), node.span);
   }
   var arg = node.arguments.$index(0);
-  if ($notnull_bool(arg.label != null)) {
+  if (arg.label != null) {
     world.error('label not allowed for directive', node.span);
   }
   return this._parseStringArgument((arg && arg.is$ArgumentNode()));
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var args = node.arguments.filter((function (a) {
-    return $notnull_bool(a.label != null && a.label.name == argName);
+    return a.label != null && a.label.name == argName;
   })
   );
-  if ($notnull_bool(args.length == 0)) {
+  if (args.length == 0) {
     return null;
   }
-  if ($notnull_bool(args.length > 1)) {
+  if (args.length > 1) {
     world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
   }
   for (var $i = args.iterator(); $i.hasNext(); ) {
     var arg = $i.next();
     return this._parseStringArgument((arg && arg.is$ArgumentNode()));
   }
 }
 _LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
-  if ($notnull_bool(!(expr instanceof LiteralExpression) || !$notnull_bool(expr.type.type.get$isString()))) {
+  if (!(expr instanceof LiteralExpression) || !$notnull_bool(expr.type.type.get$isString())) {
     world.error('expected string', expr.get$span());
   }
   return parseStringLiteral($assert_String(expr.get$value()));
 }
 _LibraryVisitor.prototype.visitTypeDefinition = function(node) {
   var oldType = this.currentType;
   this.currentType = this.library.addType(node.name.name, node, node.isClass);
   var $list = node.body;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
@@ skipping 19 matching lines @@
 }
 Parameter.prototype.is$Parameter = function(){return this;};
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 Parameter.prototype.get$name = function() { return this.name; };
 Parameter.prototype.set$name = function(value) { return this.name = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function(method, inType) {
   this.name = this.definition.name.name;
-  if ($notnull_bool(this.name.startsWith('this.'))) {
+  if (this.name.startsWith('this.')) {
     this.name = this.name.substring(5);
     this.isInitializer = true;
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(method.get$isStatic() && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.span);
   }
-  if ($notnull_bool(this.definition.value != null)) {
-    if ($notnull_bool((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start)) {
+  if (this.definition.value != null) {
+    if ((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start) {
       return;
     }
     if ($notnull_bool(method.get$isAbstract())) {
       world.error('default value not allowed on abstract methods', this.definition.span);
     }
     else if ($notnull_bool(method.name == '\$call' && method.get$definition().body == null)) {
       world.error('default value not allowed on function type', this.definition.span);
     }
   }
   else if ($notnull_bool(this.isInitializer && !$notnull_bool(method.get$isConstructor()))) {
     world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
 }
 Parameter.prototype.genValue = function(method, context) {
   var $0;
-  if ($notnull_bool(this.definition.value == null || this.value != null)) return;
-  if ($notnull_bool(context == null)) {
+  if (this.definition.value == null || this.value != null) return;
+  if (context == null) {
     context = new MethodGenerator(method, null);
   }
   this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   ret.isInitializer = this.isInitializer;
   return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
-  return $notnull_bool(this.definition != null && this.definition.value != null);
+  return this.definition != null && this.definition.value != null;
 }
 // ********** Code for Member **************
 function Member(name, declaringType) {
   this.name = name;
   this.declaringType = declaringType;
   this.isGenerated = false;
   // Initializers done
 }
 Member.prototype.is$Member = function(){return this;};
 Member.prototype.is$Named = function(){return this;};
 Member.prototype.get$name = function() { return this.name; };
 Member.prototype.get$jsname = function() {
-  return $notnull_bool(this._jsname == null) ? this.name : this._jsname;
+  return this._jsname == null ? this.name : this._jsname;
 }
 Member.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
   return this.name.startsWith('_');
 }
@@ skipping 35 matching lines @@
 }
 Member.prototype.providePropertySyntax = function() {
   return world.internalError('can not be property', this.get$span());
 }
 Member.prototype.get$initDelegate = function() {
   world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.set$initDelegate = function(ctor) {
   world.internalError('cannot have initializers', this.get$span());
 }
+Member.prototype.get$inferredResult = function() {
+  var t = this.get$returnType();
+  if ($notnull_bool(t.get$isBool() && ($notnull_bool(this.get$library().get$isCore() || this.get$library().get$isCoreImpl())))) {
+    return world.nonNullBool;
+  }
+  return (t && t.is$lang_Type());
+}
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return $notnull_bool(this.get$canGet() && new Value(this.get$returnType(), null, null, true).canInvoke(context, '\$call', args));
 }
 Member.prototype.invoke = function(context, node, target, args, isDynamic) {
   var newTarget = this._get(context, node, target, isDynamic);
   return newTarget.invoke(context, '\$call', node, args, isDynamic);
 }
 Member.prototype.override = function(other) {
   if ($notnull_bool(this.get$isStatic())) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 178, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 192, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
-  if ($notnull_bool(this.name == '')) {
+  if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
 Member.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
   if ($notnull_bool(this.get$isStatic() && type.get$hasTypeParams())) {
     world.error('using type parameter in static context', node.span);
@@ skipping 76 matching lines @@
 }
 $inherits(FieldMember, Member);
 FieldMember.prototype.is$FieldMember = function(){return this;};
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
 FieldMember.prototype.set$isNative = function(value) { return this.isNative = value; };
 FieldMember.prototype.override = function(other) {
-  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
+  if (!$notnull_bool(Member.prototype.override.call(this, other))) return false;
   if ($notnull_bool(other.get$isProperty())) {
     return true;
   }
   else {
     world.error('field can not override anything but property', this.get$span(), other.get$span());
     return false;
   }
 }
 FieldMember.prototype.get$prefersPropertySyntax = function() {
   return false;
 }
 FieldMember.prototype.get$requiresFieldSyntax = function() {
   return this.isNative;
 }
 FieldMember.prototype.provideFieldSyntax = function() {
 
 }
 FieldMember.prototype.providePropertySyntax = function() {
   this._providePropertySyntax = true;
 }
 FieldMember.prototype.get$span = function() {
   var $0;
-  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
+  return (($0 = this.definition == null ? null : this.definition.span) && $0.is$SourceSpan());
 }
 FieldMember.prototype.get$returnType = function() {
   return this.type;
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !$notnull_bool(this.isFinal);
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function(inType) {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
-  if ($notnull_bool(this.definition.modifiers != null)) {
+  if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
       if ($notnull_bool($eq(mod.kind, 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
           world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($notnull_bool($eq(mod.kind, 97/*TokenKind.FINAL*/))) {
@@ skipping 11 matching lines @@
   if ($notnull_bool(this.isStatic && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.type.span);
   }
   if ($notnull_bool(this.isStatic && this.isFinal) && this.value == null) {
     world.error('static final field is missing initializer', this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   var $0;
-  if ($notnull_bool(this.value == null)) return null;
-  if ($notnull_bool(this._computedValue == null)) {
+  if (this.value == null) return null;
+  if (this._computedValue == null) {
     if ($notnull_bool(this._computing)) {
       world.error('circular reference', this.value.span);
       return null;
     }
     this._computing = true;
     var finalMethod = new MethodMember('final_context', this.declaringType, null);
     finalMethod.isStatic = true;
     var finalGen = new MethodGenerator(finalMethod, null);
     this._computedValue = (($0 = this.value.visit(finalGen)) && $0.is$Value());
-    if ($notnull_bool(!$notnull_bool(this._computedValue.get$isConst()))) {
+    if (!$notnull_bool(this._computedValue.get$isConst())) {
       if ($notnull_bool(this.isStatic)) {
         world.error('non constant static field must be initialized in functions', this.value.span);
       }
       else {
         world.error('non constant field must be initialized in constructor', this.value.span);
       }
     }
     if ($notnull_bool(this.isStatic)) {
       this._computedValue = world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
     }
     this._computing = false;
   }
   return this._computedValue;
 }
 FieldMember.prototype._get = function(context, node, target, isDynamic) {
   var $0;
-  if ($notnull_bool(!$notnull_bool(isDynamic))) {
+  if (!$notnull_bool(isDynamic)) {
     this.declaringType.markUsed();
   }
   if ($notnull_bool(this.isStatic)) {
     var cv = this.computeValue();
     if ($notnull_bool(this.isFinal)) {
       return (cv && cv.is$Value());
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), node.span, true);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), node.span, true);
     }
   }
   else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
-    var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.get$dynamic().exp : target;
-    if ($notnull_bool((constTarget instanceof ConstObjectValue))) {
+    var constTarget = (target instanceof GlobalValue) ? target.get$dynamic().exp : target;
+    if ((constTarget instanceof ConstObjectValue)) {
       return (($0 = constTarget.fields.$index(this.name)) && $0.is$Value());
     }
     else if ($notnull_bool($eq(constTarget.type, world.stringType) && this.name == 'length')) {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), node.span, true);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
@@ skipping 11 matching lines @@
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   Member.call(this, name, declaringType);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$span = function() {
   var $0;
-  return (($0 = $notnull_bool(this.getter != null) ? this.getter.get$span() : null) && $0.is$SourceSpan());
+  return (($0 = this.getter != null ? this.getter.get$span() : null) && $0.is$SourceSpan());
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
 PropertyMember.prototype.get$canSet = function() {
   return this.setter != null;
 }
 PropertyMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 PropertyMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 PropertyMember.prototype.provideFieldSyntax = function() {
   this._provideFieldSyntax = true;
 }
 PropertyMember.prototype.providePropertySyntax = function() {
 
 }
 PropertyMember.prototype.get$isStatic = function() {
-  return $notnull_bool(this.getter == null) ? this.setter.isStatic : this.getter.isStatic;
+  return this.getter == null ? this.setter.isStatic : this.getter.isStatic;
 }
 PropertyMember.prototype.get$isProperty = function() {
   return true;
 }
 PropertyMember.prototype.get$returnType = function() {
-  return $notnull_bool(this.getter == null) ? this.setter.returnType : this.getter.returnType;
+  return this.getter == null ? this.setter.returnType : this.getter.returnType;
 }
 PropertyMember.prototype.override = function(other) {
-  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
+  if (!$notnull_bool(Member.prototype.override.call(this, other))) return false;
   if ($notnull_bool(other.get$isProperty() || other.get$isField())) {
     if ($notnull_bool(other.get$isProperty())) this.addFromParent(other);
     else this._overriddenField = other;
     return true;
   }
   else {
     world.error('property can only override field or property', this.get$span(), other.get$span());
     return false;
   }
 }
 PropertyMember.prototype._get = function(context, node, target, isDynamic) {
-  if ($notnull_bool(this.getter == null)) {
-    if ($notnull_bool(this._overriddenField != null)) {
+  if (this.getter == null) {
+    if (this._overriddenField != null) {
       return this._overriddenField._get(context, node, target, isDynamic);
     }
     return target.invokeNoSuchMethod(context, ('get:' + this.name + ''), node);
   }
   return this.getter.invoke(context, node, target, Arguments.get$EMPTY(), false);
 }
 PropertyMember.prototype._set = function(context, node, target, value, isDynamic) {
-  if ($notnull_bool(this.setter == null)) {
-    if ($notnull_bool(this._overriddenField != null)) {
+  if (this.setter == null) {
+    if (this._overriddenField != null) {
       return this._overriddenField._set(context, node, target, value, isDynamic);
     }
     return target.invokeNoSuchMethod(context, ('set:' + this.name + ''), node, new Arguments(null, [value]));
   }
   return this.setter.invoke(context, node, target, new Arguments(null, [value]), isDynamic);
 }
 PropertyMember.prototype.addFromParent = function(parentMember) {
   var $0;
   var parent;
-  if ($notnull_bool((parentMember instanceof ConcreteMember))) {
+  if ((parentMember instanceof ConcreteMember)) {
     var c = (parentMember && parentMember.is$ConcreteMember());
     parent = (($0 = c.baseMember) && $0.is$PropertyMember());
   }
   else {
     parent = (parentMember && parentMember.is$PropertyMember());
   }
-  if ($notnull_bool(this.getter == null)) this.getter = parent.getter;
-  if ($notnull_bool(this.setter == null)) this.setter = parent.setter;
+  if (this.getter == null) this.getter = parent.getter;
+  if (this.setter == null) this.setter = parent.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
-  if ($notnull_bool(this.getter != null)) this.getter.resolve(inType);
-  if ($notnull_bool(this.setter != null)) this.setter.resolve(inType);
+  if (this.getter != null) this.getter.resolve(inType);
+  if (this.setter != null) this.setter.resolve(inType);
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 PropertyMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
@@ skipping 92 matching lines @@
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var type = this.baseMember.resolveType(node, isRequired);
   return type.resolveTypeParams(this.declaringType);
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
-  return new Value(this.returnType, ret.code, node.span, true);
+  return new Value(this.get$inferredResult(), ret.code, node.span, true);
 }
 ConcreteMember.prototype._set = function(context, node, target, value, isDynamic) {
   var ret = this.baseMember._set(context, node, target, value, isDynamic);
   return new Value(this.returnType, ret.code, node.span, true);
 }
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.code;
   if ($notnull_bool(this.get$isConstructor())) {
     code = code.replaceFirst(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
   this.declaringType.genMethod(this);
-  return new Value(this.returnType, code, node.span, true);
+  return new Value(this.get$inferredResult(), code, node.span, true);
 }
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
@@ skipping 42 matching lines @@
   return (this.definition.body instanceof NativeStatement);
 }
 MethodMember.prototype.get$canGet = function() {
   return false;
 }
 MethodMember.prototype.get$canSet = function() {
   return false;
 }
 MethodMember.prototype.get$span = function() {
   var $0;
-  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
+  return (($0 = this.definition == null ? null : this.definition.span) && $0.is$SourceSpan());
 }
 MethodMember.prototype.get$constructorName = function() {
   var $0;
   var returnType = (($0 = this.definition.returnType) && $0.is$NameTypeReference());
-  if ($notnull_bool(returnType == null)) return '';
-  if ($notnull_bool(returnType.names != null)) {
+  if (returnType == null) return '';
+  if (returnType.names != null) {
     return $assert_String(returnType.names.$index(0).get$name());
   }
-  else if ($notnull_bool(returnType.name != null)) {
+  else if (returnType.name != null) {
     return returnType.name.name;
   }
   world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
-  if ($notnull_bool(this._functionType == null)) {
+  if (this._functionType == null) {
     this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
-    if ($notnull_bool(this.parameters == null)) {
+    if (this.parameters == null) {
       this.resolve(this.declaringType);
     }
   }
   return this._functionType;
 }
 MethodMember.prototype.override = function(other) {
-  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
+  if (!$notnull_bool(Member.prototype.override.call(this, other))) return false;
   if ($notnull_bool(other.get$isMethod())) {
     return true;
   }
   else {
     world.error('method can only override methods', this.get$span(), other.get$span());
     return false;
   }
 }
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
-  if ($notnull_bool(bareCount > this.parameters.length)) return false;
-  if ($notnull_bool(bareCount == this.parameters.length)) {
-    if ($notnull_bool(bareCount != args.get$length())) return false;
+  if (bareCount > this.parameters.length) return false;
+  if (bareCount == this.parameters.length) {
+    if (bareCount != args.get$length()) return false;
   }
   else {
-    if ($notnull_bool(!$notnull_bool(this.parameters.$index(bareCount).get$isOptional()))) return false;
+    if (!$notnull_bool(this.parameters.$index(bareCount).get$isOptional())) return false;
     for (var i = bareCount;
-     $notnull_bool(i < args.get$length()); i++) {
-      if ($notnull_bool(this.indexOfParameter(args.getName(i)) < 0)) {
+     i < args.get$length(); i++) {
+      if (this.indexOfParameter(args.getName(i)) < 0) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name) {
   for (var i = 0;
-   $notnull_bool(i < this.parameters.length); i++) {
+   i < this.parameters.length; i++) {
     var p = this.parameters.$index(i);
     if ($notnull_bool(p.get$isOptional() && $eq(p.get$name(), name))) {
       return i;
     }
   }
   return -1;
 }
 MethodMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
@@ skipping 13 matching lines @@
   this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
   if ($notnull_bool(this.isStatic)) {
     var type = $notnull_bool(this.declaringType.get$isTop()) ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), node.span, true);
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), node.span, true);
 }
 MethodMember.prototype.namesInOrder = function(args) {
-  if ($notnull_bool(!$notnull_bool(args.get$hasNames()))) return true;
+  if (!$notnull_bool(args.get$hasNames())) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
-   $notnull_bool(i < this.parameters.length); i++) {
+   i < this.parameters.length; i++) {
     var p = args.getIndexOfName($assert_String(this.parameters.$index(i).get$name()));
     if ($notnull_bool(p >= 0 && args.values.$index(p).needsTemp)) {
-      if ($notnull_bool(lastParameter != null && lastParameter > $assert_num(p))) {
+      if (lastParameter != null && lastParameter > $assert_num(p)) {
         return false;
       }
       lastParameter = $assert_num(p);
     }
   }
   return true;
 }
 MethodMember.prototype.needsArgumentConversion = function(args) {
   var $0;
   var bareCount = args.get$bareCount();
   for (var i = 0;
-   $notnull_bool(i < bareCount); i++) {
+   i < bareCount; i++) {
     var arg = args.values.$index(i);
     if ($notnull_bool(arg.needsConversion((($0 = this.parameters.$index(i).type) && $0.is$lang_Type())))) {
       return false;
     }
   }
-  if ($notnull_bool(bareCount < this.parameters.length)) {
+  if (bareCount < this.parameters.length) {
     this.genParameterValues();
     for (var i = bareCount;
-     $notnull_bool(i < this.parameters.length); i++) {
+     i < this.parameters.length; i++) {
       var arg = args.getValue($assert_String(this.parameters.$index(i).get$name()));
       if ($notnull_bool($ne(arg, null) && arg.needsConversion((($0 = this.parameters.$index(i).type) && $0.is$lang_Type())))) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember._argCountMsg = function(actual, expected, atLeast) {
   return 'wrong number of arguments, expected ' + ('' + ($notnull_bool(atLeast) ? "at least " : "") + '' + expected + ' but found ' + actual + '');
 }
 MethodMember.prototype._argError = function(context, node, target, args, msg) {
   if ($notnull_bool(this.isStatic || this.get$isConstructor())) {
     world.error(msg, node.span);
   }
   else {
     world.warning(msg, node.span);
   }
   return target.invokeNoSuchMethod(context, this.name, node, args);
 }
 MethodMember.prototype.genParameterValues = function() {
   var $list = this.parameters;
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     p.genValue(this, this.generator);
   }
 }
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var $0;
-  if ($notnull_bool(this.parameters == null)) {
+  if (this.parameters == null) {
     world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name + ''));
     this.resolve(this.declaringType);
   }
   this.declaringType.genMethod(this);
   if ($notnull_bool(this.isStatic || this.isFactory)) {
     this.declaringType.markUsed();
   }
-  if ($notnull_bool(!$notnull_bool(this.namesInOrder(args)))) {
+  if (!$notnull_bool(this.namesInOrder(args))) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
-  if ($notnull_bool(target != null && ($notnull_bool(this.get$isConstructor() || target.isSuper)))) {
+  if (target != null && ($notnull_bool(this.get$isConstructor() || target.isSuper))) {
     argsCode.add('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
-   $notnull_bool(i < bareCount); i++) {
+   i < bareCount; i++) {
     var arg = args.values.$index(i);
-    if ($notnull_bool(i >= this.parameters.length)) {
+    if (i >= this.parameters.length) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.length, false);
       return this._argError(context, node, target, args, $assert_String(msg));
     }
     arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
     if ($notnull_bool(this.isConst && arg.get$isConst())) {
       argsCode.add(arg.get$canonicalCode());
     }
     else {
       argsCode.add(arg.code);
     }
   }
-  if ($notnull_bool(bareCount < this.parameters.length)) {
+  if (bareCount < this.parameters.length) {
     this.genParameterValues();
     var namedArgsUsed = 0;
     for (var i = bareCount;
-     $notnull_bool(i < this.parameters.length); i++) {
+     i < this.parameters.length; i++) {
       var arg = args.getValue($assert_String(this.parameters.$index(i).get$name()));
       if ($notnull_bool(arg == null)) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
         arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
         namedArgsUsed++;
       }
       if ($notnull_bool(arg == null || !$notnull_bool(this.parameters.$index(i).get$isOptional()))) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
         argsCode.add($notnull_bool(this.isConst && arg.get$isConst()) ? arg.get$canonicalCode() : arg.code);
       }
     }
-    if ($notnull_bool(namedArgsUsed < args.get$nameCount())) {
+    if (namedArgsUsed < args.get$nameCount()) {
       var seen = new HashSetImplementation$String();
       for (var i = bareCount;
-       $notnull_bool(i < args.get$length()); i++) {
+       i < args.get$length(); i++) {
         var name = args.getName(i);
-        if ($notnull_bool(seen.contains(name))) {
+        if (seen.contains(name)) {
           return this._argError(context, node, target, args, ('duplicate argument "' + name + '"'));
         }
         seen.add(name);
         var p = this.indexOfParameter($assert_String(name));
-        if ($notnull_bool(p < 0)) {
+        if (p < 0) {
           return this._argError(context, node, target, args, ('method does not have optional parameter "' + name + '"'));
         }
-        else if ($notnull_bool(p < bareCount)) {
+        else if (p < bareCount) {
           return this._argError(context, node, target, args, ('argument "' + name + '" passed as positional and named'));
         }
       }
       world.internalError(('wrong named arguments calling ' + this.name + ''), node.span);
     }
     Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
   }
   var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
   if ($notnull_bool(this.get$isConstructor())) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
   if ($notnull_bool(target != null && target.isSuper)) {
-    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, true);
   }
-  if ($notnull_bool(this.name.startsWith('\$'))) {
-    return this._invokeBuiltin(context, node, target, args, argsCode);
+  if (this.name.startsWith('\$')) {
+    return this._invokeBuiltin(context, node, target, args, argsCode, isDynamic);
   }
   if ($notnull_bool(this.isFactory)) {
-    return new Value(this.returnType, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
-      return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), $notnull_bool(node != null) ? node.span : node, true);
+      return new Value(this.get$inferredResult(), ('' + this.get$jsname() + '(' + argsString + ')'), node != null ? node.span : node, true);
     }
-    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
-    if ($notnull_bool((target instanceof GlobalValue))) {
+    if ((target instanceof GlobalValue)) {
       target = target.get$dynamic().exp;
     }
-    if ($notnull_bool(this.name == 'get\$length')) {
-      if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
+    if (this.name == 'get\$length') {
+      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
         code = ('' + target.get$dynamic().values.length + '');
       }
     }
-    else if ($notnull_bool(this.name == 'isEmpty')) {
-      if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
+    else if (this.name == 'isEmpty') {
+      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
         code = ('' + target.get$dynamic().values.isEmpty() + '');
       }
     }
   }
-  if ($notnull_bool(this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), world.get$dom()))) {
+  if (this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), world.get$dom())) {
     world.gen.corejs.useTypeNameOf = true;
   }
-  return new Value(this.returnType, code, node.span, true);
+  return new Value(this.get$inferredResult(), code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
-  if ($notnull_bool(target != null)) {
-    var code = $notnull_bool((this.get$constructorName() != '')) ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
+  if (target != null) {
+    var code = (this.get$constructorName() != '') ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
     return new Value(this.declaringType, code, node.span, true);
   }
   else {
-    var code = $notnull_bool((this.get$constructorName() != '')) ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
-    if ($notnull_bool(this.isConst && (node instanceof lang_NewExpression)) && node.get$dynamic().get$isConst()) {
+    var code = (this.get$constructorName() != '') ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
+    if ($notnull_bool($notnull_bool(this.isConst && (node instanceof lang_NewExpression)) && node.get$dynamic().get$isConst())) {
       return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
       return new Value(this.declaringType, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
   var fields = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
-   $notnull_bool(i < this.parameters.length); i++) {
+   i < this.parameters.length; i++) {
     var param = this.parameters.$index(i);
     if ($notnull_bool(param.isInitializer)) {
       var value = null;
-      if ($notnull_bool(i < args.get$length())) {
+      if (i < args.get$length()) {
         value = args.values.$index(i);
       }
       else {
         value = args.getValue($assert_String(param.get$name()));
         if ($notnull_bool(value == null)) {
           value = param.get$value();
         }
       }
       fields.$setindex(param.get$name(), value);
     }
   }
-  if ($notnull_bool(this.definition.initializers != null)) {
+  if (this.definition.initializers != null) {
     this.generator._pushBlock(false);
     for (var j = 0;
-     $notnull_bool(j < this.definition.formals.length); j++) {
+     j < this.definition.formals.length; j++) {
       var name = this.definition.formals.$index(j).get$name().get$name();
       var value = null;
-      if ($notnull_bool(j < args.get$length())) {
+      if (j < args.get$length()) {
         value = args.values.$index(j);
       }
       else {
         value = args.getValue($assert_String(this.parameters.$index(j).get$name()));
         if ($notnull_bool(value == null)) {
           value = this.parameters.$index(j).get$value();
         }
       }
       this.generator._scope._vars.$setindex(name, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
-      if ($notnull_bool((init instanceof CallExpression))) {
+      if ((init instanceof CallExpression)) {
         var delegateArgs = this.generator._makeArgs((($0 = init.get$arguments()) && $0.is$List$ArgumentNode()));
         var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
-        if ($notnull_bool((init.target instanceof ThisExpression))) {
+        if ((init.target instanceof ThisExpression)) {
           return (value && value.is$Value());
         }
         else {
-          if ($notnull_bool((value instanceof GlobalValue))) {
+          if ((value instanceof GlobalValue)) {
             value = value.exp;
           }
           var $list0 = value.fields.getKeys();
           for (var $i0 = value.fields.getKeys().iterator(); $i0.hasNext(); ) {
             var fname = $i0.next();
             fields.$setindex(fname, value.fields.$index(fname));
           }
         }
       }
       else {
         var assign = (init && init.is$BinaryExpression());
         var x = (($0 = assign.x) && $0.is$VarExpression());
         var fname = x.name.name;
         var val = this.generator.visitValue(assign.y);
         fields.$setindex(fname, val);
       }
     }
     this.generator._popBlock();
   }
   var $list = this.declaringType.get$members().getValues();
   for (var $i = this.declaringType.get$members().getValues().iterator(); $i.hasNext(); ) {
     var f = $i.next();
-    if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic())) && $ne(f.get$value(), null) && !$notnull_bool(fields.containsKey(f.get$name()))) {
+    if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic()) && $ne(f.get$value(), null)) && !fields.containsKey(f.get$name())) {
       fields.$setindex(f.get$name(), f.computeValue());
     }
   }
   return world.gen.globalForConst(ConstObjectValue.ConstObjectValue$factory(this.declaringType, fields, code, node.span), args.values);
 }
-MethodMember.prototype._invokeBuiltin = function(context, node, target, args, argsCode) {
+MethodMember.prototype._invokeBuiltin = function(context, node, target, args, argsCode, isDynamic) {
   var allConst = $notnull_bool(target.get$isConst() && args.values.every((function (arg) {
     return arg.get$isConst();
   })
   ));
   if ($notnull_bool(this.declaringType.get$isNum())) {
-    if ($notnull_bool(!$notnull_bool(allConst))) {
+    if (!$notnull_bool(allConst)) {
       var code;
-      if ($notnull_bool(this.name == '\$negate')) {
+      if (this.name == '\$negate') {
         code = ('-' + target.code + '');
       }
-      else if ($notnull_bool(this.name == '\$bit_not')) {
+      else if (this.name == '\$bit_not') {
         code = ('~' + target.code + '');
       }
-      else if ($notnull_bool(this.name == '\$truncdiv' || this.name == '\$mod')) {
+      else if (this.name == '\$truncdiv' || this.name == '\$mod') {
         world.gen.corejs.useOperator(this.name);
         code = ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')');
       }
       else {
         var op = TokenKind.rawOperatorFromMethod(this.name);
         code = ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + '');
       }
-      return new Value(this.returnType, code, node.span, true);
+      return new Value(this.get$inferredResult(), code, node.span, true);
     }
     else {
       var value;
       var val0, val1, ival0, ival1;
       val0 = $assert_num(target.get$dynamic().get$actualValue());
       ival0 = val0.toInt();
-      if ($notnull_bool(args.values.length > 0)) {
+      if (args.values.length > 0) {
         val1 = $assert_num(args.values.$index(0).get$dynamic().get$actualValue());
         ival1 = val1.toInt();
       }
       switch (this.name) {
         case '\$negate':
 
           value = -val0;
           break;
 
         case '\$add':
@@ skipping 85 matching lines @@
 
           value = (ival0 >> ival1).toDouble();
           break;
 
         case '\$shr':
 
           value = (ival0 >>> ival1).toDouble();
           break;
 
       }
-      return EvaluatedValue.EvaluatedValue$factory(this.returnType, value, ("" + value + ""), node.span);
+      return EvaluatedValue.EvaluatedValue$factory(this.get$inferredResult(), value, ("" + value + ""), node.span);
     }
   }
   else if ($notnull_bool(this.declaringType.get$isString())) {
-    if ($notnull_bool(this.name == '\$index')) {
+    if (this.name == '\$index') {
       return new Value(this.declaringType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
-    else if ($notnull_bool(this.name == '\$add')) {
+    else if (this.name == '\$add') {
       if ($notnull_bool(allConst)) {
         var val0 = target.get$dynamic().get$actualValue();
         val0 = val0.substring(1, val0.length - 1);
         var val1 = args.values.$index(0).get$dynamic().get$actualValue();
         if ($notnull_bool(args.values.$index(0).type.get$isString())) {
           val1 = val1.substring(1, val1.length - 1);
         }
         var value = ('' + val0 + '' + val1 + '');
         value = '"' + value.replaceAll('"', '\\"') + '"';
         return EvaluatedValue.EvaluatedValue$factory(world.stringType, value, $assert_String(value), node.span);
       }
       args.values.$index(0).invoke$4(context, 'toString', node, Arguments.get$EMPTY());
       return new Value(this.declaringType, ('' + target.code + ' + ' + argsCode.$index(0) + ''), node.span, true);
     }
   }
   else if ($notnull_bool(this.declaringType.get$isNativeType())) {
-    if ($notnull_bool(this.name == '\$index')) {
+    if (this.name == '\$index') {
       return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
-    else if ($notnull_bool(this.name == '\$setindex')) {
+    else if (this.name == '\$setindex') {
       return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + '] = ' + argsCode.$index(1) + ''), node.span, true);
     }
   }
-  if ($notnull_bool(this.name == '\$eq' || this.name == '\$ne')) {
-    var op = $notnull_bool(this.name == '\$eq') ? '==' : '!=';
+  if (this.name == '\$eq' || this.name == '\$ne') {
+    var op = this.name == '\$eq' ? '==' : '!=';
+    if (this.name == '\$ne') {
+      target.invoke(context, '\$eq', node, args, isDynamic);
+    }
     if ($notnull_bool(allConst)) {
       var val0 = target.get$dynamic().get$actualValue();
       var val1 = args.values.$index(0).get$dynamic().get$actualValue();
-      var newVal = $notnull_bool(this.name == '\$eq') ? $eq(val0, val1) : $ne(val0, val1);
-      return EvaluatedValue.EvaluatedValue$factory(world.boolType, newVal, ("" + newVal + ""), node.span);
+      var newVal = this.name == '\$eq' ? $eq(val0, val1) : $ne(val0, val1);
+      return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, newVal, ("" + newVal + ""), node.span);
     }
     if ($notnull_bool($eq(argsCode.$index(0), 'null'))) {
-      return new Value(this.returnType, ('' + target.code + ' ' + op + ' null'), node.span, true);
+      return new Value(this.get$inferredResult(), ('' + target.code + ' ' + op + ' null'), node.span, true);
     }
     else if ($notnull_bool(target.type.get$isNum() || target.type.get$isString())) {
-      return new Value(this.returnType, ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), node.span, true);
+      return new Value(this.get$inferredResult(), ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), node.span, true);
     }
     world.gen.corejs.useOperator(this.name);
-    return new Value(this.returnType, ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), node.span, true);
   }
-  if ($notnull_bool(this.name == '\$call')) {
+  if (this.name == '\$call') {
     this.declaringType.markUsed();
-    return new Value(this.returnType, ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), node.span, true);
+    return new Value(this.get$inferredResult(), ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), node.span, true);
   }
-  if ($notnull_bool(this.name == '\$index')) {
+  if (this.name == '\$index') {
     world.gen.corejs.useIndex = true;
   }
-  else if ($notnull_bool(this.name == '\$setindex')) {
+  else if (this.name == '\$setindex') {
     world.gen.corejs.useSetIndex = true;
   }
   var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
-  return new Value(this.returnType, ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
+  return new Value(this.get$inferredResult(), ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
 }
 MethodMember.prototype.resolve = function(inType) {
   this.isStatic = inType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !$notnull_bool(this.declaringType.get$isClass());
-  if ($notnull_bool(this.definition.modifiers != null)) {
+  if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
       if ($notnull_bool($eq(mod.kind, 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
           world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
       else if ($notnull_bool(this.get$isConstructor() && $eq(mod.kind, 91/*TokenKind.CONST*/))) {
@@ skipping 20 matching lines @@
         this.isAbstract = true;
       }
       else {
         world.error(('' + mod + ' modifier not allowed on method'), mod.get$span());
       }
     }
   }
   if ($notnull_bool(this.isFactory)) {
     this.isStatic = true;
   }
-  if ($notnull_bool(this.name.startsWith('\$') && !$notnull_bool(this.name.startsWith('\$call'))) && this.isStatic) {
+  if ($notnull_bool(this.name.startsWith('\$') && !this.name.startsWith('\$call') && this.isStatic)) {
     world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if ($notnull_bool(this.isAbstract)) {
-    if ($notnull_bool(this.definition.body != null && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition))) {
+    if (this.definition.body != null && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition)) {
       world.error('abstract method can not have a body', this.get$span());
     }
     if ($notnull_bool(this.isStatic && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition))) {
       world.error('static method can not be abstract', this.get$span());
     }
   }
   else {
-    if ($notnull_bool(this.definition.body == null && !$notnull_bool(this.get$isConstructor()))) {
+    if (this.definition.body == null && !$notnull_bool(this.get$isConstructor())) {
       world.error('method needs a body', this.get$span());
     }
   }
   if ($notnull_bool(this.get$isConstructor())) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = inType.resolveType(this.definition.returnType, false);
     if ($notnull_bool(this.isStatic && this.returnType.get$hasTypeParams())) {
       world.error('using type parameter in static context', this.definition.returnType.span);
     }
   }
   this.parameters = [];
   var $list = this.definition.formals;
   for (var $i = 0;$i < $list.length; $i++) {
     var formal = $list.$index($i);
     var param = new Parameter(formal);
     param.resolve(this, inType);
     this.parameters.add(param);
   }
-  if ($notnull_bool(!$notnull_bool(this.isLambda))) {
+  if (!$notnull_bool(this.isLambda)) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), $1, ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
@@ skipping 28 matching lines @@
 MemberSet.prototype.get$isStatic = function() {
   return $notnull_bool(this.members.length == 1 && this.members.$index(0).get$isStatic());
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
-  if ($notnull_bool(!$notnull_bool(target.type.get$isVar()))) {
+  if (!$notnull_bool(target.type.get$isVar())) {
     world.warning(('could not find applicable ' + action + ' for "' + this.name + '"'), node.span);
   }
   return new Value(world.varType, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), node.span, true);
 }
 MemberSet.prototype.get$treatAsField = function() {
-  if ($notnull_bool(this._treatAsField == null)) {
+  if (this._treatAsField == null) {
     this._treatAsField = true;
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(member.get$requiresFieldSyntax())) {
         this._treatAsField = true;
         break;
       }
       if ($notnull_bool(member.get$prefersPropertySyntax())) {
         this._treatAsField = false;
       }
     }
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(this._treatAsField)) {
         member.provideFieldSyntax();
       }
       else {
         member.providePropertySyntax();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
-  if ($notnull_bool(this.members.length == 1)) {
+  if (this.members.length == 1) {
     return this.members.$index(0)._get(context, node, target, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.get$canGet();
   })
   );
-  if ($notnull_bool(targets.length == 1)) {
+  if (targets.length == 1) {
     return targets.$index(0)._get(context, node, target, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
     var value = member._get(context, node, target, true);
     returnValue = this._tryUnion(returnValue, value, node);
   }
-  if ($notnull_bool(returnValue == null)) {
+  if (returnValue == null) {
     return this._makeError(node, target, 'getter');
   }
-  if ($notnull_bool(returnValue.code == null)) {
+  if (returnValue.code == null) {
     if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), node.span, true);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
-  if ($notnull_bool(this.members.length == 1)) {
+  if (this.members.length == 1) {
     return this.members.$index(0)._set(context, node, target, value, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
-  if ($notnull_bool(targets.length == 1)) {
+  if (targets.length == 1) {
     return targets.$index(0)._set(context, node, target, value, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
     var res = member._set(context, node, target, value, true);
     returnValue = this._tryUnion(returnValue, res, node);
   }
-  if ($notnull_bool(returnValue == null)) {
+  if (returnValue == null) {
     return this._makeError(node, target, 'setter');
   }
-  if ($notnull_bool(returnValue.code == null)) {
+  if (returnValue.code == null) {
     if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), node.span, true);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
-  if ($notnull_bool(this.members.length == 1)) {
+  if (this.members.length == 1) {
     return this.members.$index(0).invoke(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke(context, args);
   })
   );
-  if ($notnull_bool(targets.length == 1)) {
+  if (targets.length == 1) {
     return targets.$index(0).invoke(context, node, target, args, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
     var res = member.invoke(context, node, target, args, true);
     returnValue = this._tryUnion(returnValue, res, node);
   }
-  if ($notnull_bool(returnValue == null)) {
+  if (returnValue == null) {
     return this._makeError(node, target, 'method');
   }
-  if ($notnull_bool(returnValue.code == null)) {
-    if ($notnull_bool(this.name.startsWith('\$'))) {
+  if (returnValue.code == null) {
+    if (this.name.startsWith('\$')) {
       return target.invokeSpecial(this.name, args, returnValue.type);
     }
     else {
       return this.invokeOnVar(context, node, target, args);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invokeOnVar = function(context, node, target, args) {
   return this.getVarMember(context, node, args).invoke(context, node, target, args);
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
-  if ($notnull_bool(x == null)) return y;
+  if (x == null) return y;
   var type = lang_Type.union(x.type, y.type);
-  if ($notnull_bool(x.code == y.code)) {
+  if (x.code == y.code) {
     if ($notnull_bool($eq(type, x.type))) {
       return x;
     }
     else if ($notnull_bool(x.get$isConst() || y.get$isConst())) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       var ret = new Value(type, x.code, node.span, true);
       ret.isSuper = $notnull_bool(x.isSuper && y.isSuper);
       ret.needsTemp = $notnull_bool(x.needsTemp || y.needsTemp);
       ret.isType = $notnull_bool(x.isType && y.isType);
       return (ret && ret.is$Value());
     }
   }
   else {
     return new Value(type, null, node.span, true);
   }
 }
 MemberSet.prototype.getVarMember = function(context, node, args) {
-  if ($notnull_bool(world.objectType.varStubs == null)) {
+  if (world.objectType.varStubs == null) {
     world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = world.objectType.varStubs.$index(stubName);
   if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
     var targets = mset.filter((function (m) {
       return m.canInvoke(context, args);
     })
     );
@@ skipping 55 matching lines @@
   this.end = end;
   // Initializers done
 }
 lang_Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 lang_Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($notnull_bool($ne(kindText, actualText))) {
-    if ($notnull_bool(actualText.length > 10)) {
+    if (actualText.length > 10) {
       actualText = actualText.substring(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return $assert_String(kindText);
   }
 }
 lang_Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.is$SourceFile = function(){return this;};
 SourceFile.prototype.get$text = function() {
   return this._text;
 }
 SourceFile.prototype.get$lineStarts = function() {
-  if ($notnull_bool(this._lineStarts == null)) {
+  if (this._lineStarts == null) {
     var starts = [0];
     var index = 0;
-    while ($notnull_bool(index < this.get$text().length)) {
+    while (index < this.get$text().length) {
       index = this.get$text().indexOf('\n', index) + 1;
-      if ($notnull_bool(index <= 0)) break;
+      if (index <= 0) break;
       starts.add(index);
     }
     starts.add(this.get$text().length + 1);
     this._lineStarts = (starts && starts.is$List$int());
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = 0;
-   $notnull_bool(i < starts.length); i++) {
-    if ($notnull_bool(starts.$index(i) > position)) return i - 1;
+   i < starts.length; i++) {
+    if (starts.$index(i) > position) return i - 1;
   }
   world.internalError('bad position');
 }
 SourceFile.prototype.getColumn = function(line, position) {
   return position - $assert_num(this.get$lineStarts().$index(line));
 }
 SourceFile.prototype.getLocationMessage = function(message, start, end, includeText) {
   var line = this.getLine(start);
   var column = this.getColumn($assert_num(line), start);
   var buf = new StringBufferImpl(('' + this.filename + ':' + (line + 1) + ':' + (column + 1) + ': ' + message + ''));
   if ($notnull_bool(includeText)) {
     buf.add('\n');
     var textLine;
-    if ($notnull_bool((line + 2) < this._lineStarts.length)) {
+    if ((line + 2) < this._lineStarts.length) {
       textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index(line + 1));
     }
     else {
       textLine = this.get$text().substring(this._lineStarts.$index(line)) + '\n';
     }
     buf.add(textLine);
     var i = 0;
-    for (; $notnull_bool(i < $assert_num(column)); i++) {
+    for (; i < $assert_num(column); i++) {
       buf.add(' ');
     }
     var toColumn = Math.min($assert_num(column + (end - start)), textLine.length);
-    for (; $notnull_bool(i < toColumn); i++) {
+    for (; i < toColumn; i++) {
       buf.add('^');
     }
   }
   return $assert_String(buf.toString());
 }
 SourceFile.prototype.compareTo = function(other) {
-  if ($notnull_bool(this.orderInLibrary != null && other.orderInLibrary != null)) {
+  if (this.orderInLibrary != null && other.orderInLibrary != null) {
     return this.orderInLibrary - other.orderInLibrary;
   }
   else {
     return this.filename.compareTo(other.filename);
   }
 }
 // ********** Code for SourceSpan **************
 function SourceSpan(file, start, end) {
   this.file = file;
   this.start = start;
   this.end = end;
   // Initializers done
 }
 SourceSpan.prototype.is$SourceSpan = function(){return this;};
 SourceSpan.prototype.get$text = function() {
   return this.file.get$text().substring(this.start, this.end);
 }
 SourceSpan.prototype.toMessageString = function(message) {
   return this.file.getLocationMessage(message, this.start, this.end, true);
 }
 SourceSpan.prototype.get$locationText = function() {
   var line = this.file.getLine(this.start);
   var column = this.file.getColumn($assert_num(line), this.start);
   return ('' + this.file.filename + ':' + (line + 1) + ':' + (column + 1) + '');
 }
 SourceSpan.prototype.compareTo = function(other) {
-  if ($notnull_bool($eq(this.file, other.file))) {
+  if ($eq(this.file, other.file)) {
     var d = this.start - other.start;
-    return $notnull_bool(d == 0) ? (this.end - other.end) : d;
+    return d == 0 ? (this.end - other.end) : d;
   }
   return this.file.compareTo(other.file);
 }
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = -1;
   // Initializers done
 }
 InterpStack.prototype.is$InterpStack = function(){return this;};
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
-  if ($notnull_bool(stack != null)) newStack.previous = stack;
+  if (stack != null) newStack.previous = stack;
   return (newStack && newStack.is$InterpStack());
 }
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._lang_index = _index;
   // Initializers done
   this._text = this._source.get$text();
 }
 $inherits(TokenizerBase, TokenizerHelpers);
 TokenizerBase.prototype._nextChar = function() {
-  if ($notnull_bool(this._lang_index < this._text.length)) {
+  if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._peekChar = function() {
-  if ($notnull_bool(this._lang_index < this._text.length)) {
+  if (this._lang_index < this._text.length) {
     return this._text.charCodeAt(this._lang_index);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._maybeEatChar = function(ch) {
-  if ($notnull_bool(this._lang_index < this._text.length)) {
-    if ($notnull_bool(this._text.charCodeAt(this._lang_index) == ch)) {
+  if (this._lang_index < this._text.length) {
+    if (this._text.charCodeAt(this._lang_index) == ch) {
       this._lang_index++;
       return true;
     }
     else {
       return false;
     }
   }
   else {
     return false;
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
   return new lang_Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function() {
   return this._finishToken(65/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
-  while ($notnull_bool(this._lang_index < this._text.length)) {
-    if ($notnull_bool(!$notnull_bool(TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++))))) {
+  while (this._lang_index < this._text.length) {
+    if (!$notnull_bool(TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++)))) {
       this._lang_index--;
       if ($notnull_bool(this._skipWhitespace)) {
         return this.next();
       }
       else {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
 TokenizerBase.prototype.finishHashBang = function() {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0 || ch == 10) || ch == 13) {
+    if (ch == 0 || ch == 10 || ch == 13) {
       return this._finishToken(13/*TokenKind.HASHBANG*/);
     }
   }
 }
 TokenizerBase.prototype.finishSingleLineComment = function() {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0 || ch == 10) || ch == 13) {
+    if (ch == 0 || ch == 10 || ch == 13) {
       if ($notnull_bool(this._skipWhitespace)) {
         return this.next();
       }
       else {
         return this._finishToken(64/*TokenKind.COMMENT*/);
       }
     }
   }
 }
 TokenizerBase.prototype.finishMultiLineComment = function() {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0)) {
+    if (ch == 0) {
       return this._finishToken(67/*TokenKind.INCOMPLETE_COMMENT*/);
     }
-    else if ($notnull_bool(ch == 42)) {
+    else if (ch == 42) {
       if ($notnull_bool(this._maybeEatChar(47))) {
         if ($notnull_bool(this._skipWhitespace)) {
           return this.next();
         }
         else {
           return this._finishToken(64/*TokenKind.COMMENT*/);
         }
       }
     }
   }
   return this._errorToken();
 }
 TokenizerBase.prototype.eatDigits = function() {
-  while ($notnull_bool(this._lang_index < this._text.length)) {
+  while (this._lang_index < this._text.length) {
     if ($notnull_bool(TokenizerHelpers.isDigit(this._text.charCodeAt(this._lang_index)))) {
       this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.eatHexDigits = function() {
-  while ($notnull_bool(this._lang_index < this._text.length)) {
+  while (this._lang_index < this._text.length) {
     if ($notnull_bool(TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index)))) {
       this._lang_index++;
     }
     else {
       return;
     }
   }
 }
 TokenizerBase.prototype.maybeEatHexDigit = function() {
   if ($notnull_bool(this._lang_index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index)))) {
     this._lang_index++;
     return true;
   }
   return false;
 }
 TokenizerBase.prototype.finishHex = function() {
   this.eatHexDigits();
   return this._finishToken(61/*TokenKind.HEX_INTEGER*/);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
-  if ($notnull_bool(this._peekChar() == 46)) {
+  if (this._peekChar() == 46) {
     this._nextChar();
     if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
       this.eatDigits();
       return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
     }
     else {
       this._lang_index--;
     }
   }
   return this.finishNumberExtra(60/*TokenKind.INTEGER*/);
 }
 TokenizerBase.prototype.finishNumberExtra = function(kind) {
   if ($notnull_bool(this._maybeEatChar(101) || this._maybeEatChar(69))) {
     kind = 62/*TokenKind.DOUBLE*/;
     this._maybeEatChar(45);
     this._maybeEatChar(43);
     this.eatDigits();
   }
   if ($notnull_bool(this._peekChar() != 0 && TokenizerHelpers.isIdentifierStart(this._peekChar()))) {
     this._nextChar();
     return this._errorToken();
   }
   return this._finishToken(kind);
 }
 TokenizerBase.prototype.finishMultilineString = function(quote) {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0)) {
-      var kind = $notnull_bool(quote == 34) ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
+    if (ch == 0) {
+      var kind = quote == 34 ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
       return this._finishToken(kind);
     }
-    else if ($notnull_bool(ch == quote)) {
+    else if (ch == quote) {
       if ($notnull_bool(this._maybeEatChar(quote))) {
         if ($notnull_bool(this._maybeEatChar(quote))) {
           return this._finishToken(58/*TokenKind.STRING*/);
         }
       }
     }
-    else if ($notnull_bool(ch == 36)) {
+    else if (ch == 36) {
       this._interpStack = InterpStack.push(this._interpStack, quote, true);
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if ($notnull_bool(ch == 92)) {
-      if ($notnull_bool(!$notnull_bool(this.eatEscapeSequence()))) {
+    else if (ch == 92) {
+      if (!$notnull_bool(this.eatEscapeSequence())) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
-  if ($notnull_bool(this._interpStack != null)) {
-    if ($notnull_bool(this._interpStack.depth == -1)) {
+  if (this._interpStack != null) {
+    if (this._interpStack.depth == -1) {
       this._interpStack.depth = 1;
     }
     else {
       $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 261, 16);
       ($0 = this._interpStack).depth = $0.depth + 1;
     }
   }
   return this._finishToken(6/*TokenKind.LBRACE*/);
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
-  if ($notnull_bool(this._interpStack != null)) {
+  if (this._interpStack != null) {
     ($0 = this._interpStack).depth = $0.depth - 1;
     $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 271, 14);
   }
   return this._finishToken(7/*TokenKind.RBRACE*/);
 }
 TokenizerBase.prototype.finishString = function(quote) {
   if ($notnull_bool(this._maybeEatChar(quote))) {
     if ($notnull_bool(this._maybeEatChar(quote))) {
       return this.finishMultilineString(quote);
     }
     else {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
   }
   return this.finishStringBody(quote);
 }
 TokenizerBase.prototype.finishRawString = function(quote) {
   if ($notnull_bool(this._maybeEatChar(quote))) {
     if ($notnull_bool(this._maybeEatChar(quote))) {
       return this.finishMultilineRawString(quote);
     }
     else {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
   }
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == quote)) {
+    if (ch == quote) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
-    else if ($notnull_bool(ch == 0)) {
+    else if (ch == 0) {
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
   }
 }
 TokenizerBase.prototype.finishMultilineRawString = function(quote) {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0)) {
-      var kind = $notnull_bool(quote == 34) ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
+    if (ch == 0) {
+      var kind = quote == 34 ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
       return this._finishToken(kind);
     }
-    else if ($notnull_bool(ch == quote && this._maybeEatChar(quote)) && this._maybeEatChar(quote)) {
+    else if ($notnull_bool($notnull_bool(ch == quote && this._maybeEatChar(quote)) && this._maybeEatChar(quote))) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
   }
 }
 TokenizerBase.prototype.finishStringBody = function(quote) {
-  while ($notnull_bool(true)) {
+  while (true) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == quote)) {
+    if (ch == quote) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
-    else if ($notnull_bool(ch == 36)) {
+    else if (ch == 36) {
       this._interpStack = InterpStack.push(this._interpStack, quote, false);
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if ($notnull_bool(ch == 0)) {
+    else if (ch == 0) {
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if ($notnull_bool(ch == 92)) {
-      if ($notnull_bool(!$notnull_bool(this.eatEscapeSequence()))) {
+    else if (ch == 92) {
+      if (!$notnull_bool(this.eatEscapeSequence())) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
       return $notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit());
 
     case 117:
 
       if ($notnull_bool(this._maybeEatChar(123))) {
         var start = this._lang_index;
         this.eatHexDigits();
         var chars = this._lang_index - start;
-        if ($notnull_bool(chars > 0 && chars <= 6) && this._maybeEatChar(125)) {
+        if ($notnull_bool(chars > 0 && chars <= 6 && this._maybeEatChar(125))) {
           hex = this._text.substring(start, start + chars);
           break;
         }
         else {
           return false;
         }
       }
       else {
-        if ($notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit()) && this.maybeEatHexDigit() && this.maybeEatHexDigit()) {
+        if ($notnull_bool($notnull_bool($notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit()) && this.maybeEatHexDigit()) && this.maybeEatHexDigit())) {
           hex = this._text.substring(this._lang_index - 4, this._lang_index);
           break;
         }
         else {
           return false;
         }
       }
 
     default:
 
       return true;
 
   }
   var n = lang_Parser.parseHex(hex);
-  return $notnull_bool(n < 0xD800 || $notnull_bool(n > 0xDFFF && n <= 0x10FFFF));
+  return n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
 }
 TokenizerBase.prototype.finishDot = function() {
   if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
     this.eatDigits();
     return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function() {
-  while ($notnull_bool(this._lang_index < this._text.length)) {
-    if ($notnull_bool(!$notnull_bool(TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))))) {
+  while (this._lang_index < this._text.length) {
+    if (!$notnull_bool(TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++)))) {
       this._lang_index--;
       break;
     }
   }
   var kind = this.getIdentifierKind();
-  if ($notnull_bool(this._interpStack != null && this._interpStack.depth == -1)) {
+  if (this._interpStack != null && this._interpStack.depth == -1) {
     this._interpStack.depth = 0;
   }
-  if ($notnull_bool(kind == 70/*TokenKind.IDENTIFIER*/)) {
+  if (kind == 70/*TokenKind.IDENTIFIER*/) {
     return this._finishToken(70/*TokenKind.IDENTIFIER*/);
   }
   else {
     return this._finishToken(kind);
   }
 }
 // ********** Code for Tokenizer **************
 function Tokenizer(source, skipWhitespace, index) {
   TokenizerBase.call(this, source, skipWhitespace, index);
   // Initializers done
 }
 $inherits(Tokenizer, TokenizerBase);
 Tokenizer.prototype.next = function() {
   this._startIndex = this._lang_index;
-  if ($notnull_bool(this._interpStack != null && this._interpStack.depth == 0)) {
+  if (this._interpStack != null && this._interpStack.depth == 0) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
     if ($notnull_bool(istack.isMultiline)) {
       return this.finishMultilineString(istack.quote);
     }
     else {
       return this.finishStringBody(istack.quote);
     }
   }
   var ch;
@@ skipping 316 matching lines @@
         return this._errorToken();
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
   switch (this._lang_index - i0) {
     case 2:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 100)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) return 94/*TokenKind.DO*/;
+      if (this._text.charCodeAt(i0) == 100) {
+        if (this._text.charCodeAt(i0 + 1) == 111) return 94/*TokenKind.DO*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 105)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 102)) {
+      else if (this._text.charCodeAt(i0) == 105) {
+        if (this._text.charCodeAt(i0 + 1) == 102) {
           return 100/*TokenKind.IF*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 110)) {
+        else if (this._text.charCodeAt(i0 + 1) == 110) {
           return 101/*TokenKind.IN*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 115)) {
+        else if (this._text.charCodeAt(i0 + 1) == 115) {
           return 102/*TokenKind.IS*/;
         }
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 3:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 102)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114)) return 99/*TokenKind.FOR*/;
+      if (this._text.charCodeAt(i0) == 102) {
+        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114) return 99/*TokenKind.FOR*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 103)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116)) return 76/*TokenKind.GET*/;
+      else if (this._text.charCodeAt(i0) == 103) {
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 76/*TokenKind.GET*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 110)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119)) return 103/*TokenKind.NEW*/;
+      else if (this._text.charCodeAt(i0) == 110) {
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119) return 103/*TokenKind.NEW*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 115)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116)) return 84/*TokenKind.SET*/;
+      else if (this._text.charCodeAt(i0) == 115) {
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 84/*TokenKind.SET*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121)) return 111/*TokenKind.TRY*/;
+      else if (this._text.charCodeAt(i0) == 116) {
+        if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121) return 111/*TokenKind.TRY*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 118)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114)) return 112/*TokenKind.VAR*/;
+      else if (this._text.charCodeAt(i0) == 118) {
+        if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114) return 112/*TokenKind.VAR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 4:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101) return 89/*TokenKind.CASE*/;
+      if (this._text.charCodeAt(i0) == 99) {
+        if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 89/*TokenKind.CASE*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 101)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101) return 95/*TokenKind.ELSE*/;
+      else if (this._text.charCodeAt(i0) == 101) {
+        if (this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101) return 95/*TokenKind.ELSE*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 110)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108) && this._text.charCodeAt(i0 + 3) == 108) return 104/*TokenKind.NULL*/;
+      else if (this._text.charCodeAt(i0) == 110) {
+        if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 108) return 104/*TokenKind.NULL*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115)) return 108/*TokenKind.THIS*/;
+      else if (this._text.charCodeAt(i0) == 116) {
+        if (this._text.charCodeAt(i0 + 1) == 104) {
+          if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115) return 108/*TokenKind.THIS*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101)) return 110/*TokenKind.TRUE*/;
+        else if (this._text.charCodeAt(i0 + 1) == 114) {
+          if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101) return 110/*TokenKind.TRUE*/;
         }
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 118)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105) && this._text.charCodeAt(i0 + 3) == 100) return 113/*TokenKind.VOID*/;
+      else if (this._text.charCodeAt(i0) == 118) {
+        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 100) return 113/*TokenKind.VOID*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 5:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 98)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101) && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107) return 88/*TokenKind.BREAK*/;
+      if (this._text.charCodeAt(i0) == 98) {
+        if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107) return 88/*TokenKind.BREAK*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99) && this._text.charCodeAt(i0 + 4) == 104) return 90/*TokenKind.CATCH*/;
+      else if (this._text.charCodeAt(i0) == 99) {
+        if (this._text.charCodeAt(i0 + 1) == 97) {
+          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99 && this._text.charCodeAt(i0 + 4) == 104) return 90/*TokenKind.CATCH*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 108)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 115) return 73/*TokenKind.CLASS*/;
+        else if (this._text.charCodeAt(i0 + 1) == 108) {
+          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115) return 73/*TokenKind.CLASS*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 116) return 91/*TokenKind.CONST*/;
+        else if (this._text.charCodeAt(i0 + 1) == 111) {
+          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116) return 91/*TokenKind.CONST*/;
         }
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 102)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 101) return 96/*TokenKind.FALSE*/;
+      else if (this._text.charCodeAt(i0) == 102) {
+        if (this._text.charCodeAt(i0 + 1) == 97) {
+          if (this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 101) return 96/*TokenKind.FALSE*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 108) return 97/*TokenKind.FINAL*/;
+        else if (this._text.charCodeAt(i0 + 1) == 105) {
+          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108) return 97/*TokenKind.FINAL*/;
         }
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 115)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114) return 106/*TokenKind.SUPER*/;
+      else if (this._text.charCodeAt(i0) == 115) {
+        if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114) return 106/*TokenKind.SUPER*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114) && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119) return 109/*TokenKind.THROW*/;
+      else if (this._text.charCodeAt(i0) == 116) {
+        if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119) return 109/*TokenKind.THROW*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 119)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105) && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101) return 114/*TokenKind.WHILE*/;
+      else if (this._text.charCodeAt(i0) == 119) {
+        if (this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101) return 114/*TokenKind.WHILE*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 6:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 97)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 72/*TokenKind.ASSERT*/;
+      if (this._text.charCodeAt(i0) == 97) {
+        if (this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 72/*TokenKind.ASSERT*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 105)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 78/*TokenKind.IMPORT*/;
+      else if (this._text.charCodeAt(i0) == 105) {
+        if (this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 78/*TokenKind.IMPORT*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 110)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105) && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 81/*TokenKind.NATIVE*/;
+      else if (this._text.charCodeAt(i0) == 110) {
+        if (this._text.charCodeAt(i0 + 1) == 97) {
+          if (this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 81/*TokenKind.NATIVE*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 82/*TokenKind.NEGATE*/;
+        else if (this._text.charCodeAt(i0 + 1) == 101) {
+          if (this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 82/*TokenKind.NEGATE*/;
         }
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 114)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110) return 105/*TokenKind.RETURN*/;
+      else if (this._text.charCodeAt(i0) == 114) {
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110) return 105/*TokenKind.RETURN*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 115)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114) && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101) return 85/*TokenKind.SOURCE*/;
+      else if (this._text.charCodeAt(i0) == 115) {
+        if (this._text.charCodeAt(i0 + 1) == 111) {
+          if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101) return 85/*TokenKind.SOURCE*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 116)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99) return 86/*TokenKind.STATIC*/;
+        else if (this._text.charCodeAt(i0 + 1) == 116) {
+          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99) return 86/*TokenKind.STATIC*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 119)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104) return 107/*TokenKind.SWITCH*/;
+        else if (this._text.charCodeAt(i0 + 1) == 119) {
+          if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104) return 107/*TokenKind.SWITCH*/;
         }
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 7:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 100)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102) && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116) return 93/*TokenKind.DEFAULT*/;
+      if (this._text.charCodeAt(i0) == 100) {
+        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116) return 93/*TokenKind.DEFAULT*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 101)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115) return 74/*TokenKind.EXTENDS*/;
+      else if (this._text.charCodeAt(i0) == 101) {
+        if (this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115) return 74/*TokenKind.EXTENDS*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 102)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 75/*TokenKind.FACTORY*/;
+      else if (this._text.charCodeAt(i0) == 102) {
+        if (this._text.charCodeAt(i0 + 1) == 97) {
+          if (this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 75/*TokenKind.FACTORY*/;
         }
-        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121) return 98/*TokenKind.FINALLY*/;
+        else if (this._text.charCodeAt(i0 + 1) == 105) {
+          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121) return 98/*TokenKind.FINALLY*/;
         }
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 108)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98) && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 80/*TokenKind.LIBRARY*/;
+      else if (this._text.charCodeAt(i0) == 108) {
+        if (this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 80/*TokenKind.LIBRARY*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102) return 87/*TokenKind.TYPEDEF*/;
+      else if (this._text.charCodeAt(i0) == 116) {
+        if (this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102) return 87/*TokenKind.TYPEDEF*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 8:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 97)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116) return 71/*TokenKind.ABSTRACT*/;
+      if (this._text.charCodeAt(i0) == 97) {
+        if (this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116) return 71/*TokenKind.ABSTRACT*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110) && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101) return 92/*TokenKind.CONTINUE*/;
+      else if (this._text.charCodeAt(i0) == 99) {
+        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101) return 92/*TokenKind.CONTINUE*/;
       }
-      else if ($notnull_bool(this._text.charCodeAt(i0) == 111)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101) && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114) return 83/*TokenKind.OPERATOR*/;
+      else if (this._text.charCodeAt(i0) == 111) {
+        if (this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114) return 83/*TokenKind.OPERATOR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 9:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110) && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101) return 79/*TokenKind.INTERFACE*/;
+      if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101) return 79/*TokenKind.INTERFACE*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 10:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109) && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 77/*TokenKind.IMPLEMENTS*/;
+      if (this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 77/*TokenKind.IMPLEMENTS*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 // ********** Code for TokenizerHelpers **************
 function TokenizerHelpers() {}
 TokenizerHelpers.isIdentifierStart = function(c) {
-  return ($notnull_bool(($notnull_bool(c >= 97 && c <= 122)) || ($notnull_bool(c >= 65 && c <= 90))) || c == 95);
+  return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
 }
 TokenizerHelpers.isDigit = function(c) {
-  return ($notnull_bool(c >= 48 && c <= 57));
+  return (c >= 48 && c <= 57);
 }
 TokenizerHelpers.isHexDigit = function(c) {
-  return ($notnull_bool(TokenizerHelpers.isDigit(c) || ($notnull_bool(c >= 97 && c <= 102))) || ($notnull_bool(c >= 65 && c <= 70)));
+  return ($notnull_bool(TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102)) || (c >= 65 && c <= 70));
 }
 TokenizerHelpers.isWhitespace = function(c) {
-  return ($notnull_bool(c == 32 || c == 9) || c == 10 || c == 13);
+  return (c == 32 || c == 9 || c == 10 || c == 13);
 }
 TokenizerHelpers.isIdentifierPart = function(c) {
   return ($notnull_bool(TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c)));
 }
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
     case 1/*TokenKind.END_OF_FILE*/:
 
@@ skipping 451 matching lines @@
 
       return "keyword 'while'";
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
-  return $notnull_bool(kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 88/*TokenKind.BREAK*/);
+  return kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 88/*TokenKind.BREAK*/;
 }
 TokenKind.infixPrecedence = function(kind) {
   switch (kind) {
     case 20/*TokenKind.ASSIGN*/:
 
       return 2;
 
     case 21/*TokenKind.ASSIGN_OR*/:
 
       return 2;
@@ skipping 310 matching lines @@
 
       return '\$index';
 
     case 57/*TokenKind.SETINDEX*/:
 
       return '\$setindex';
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
-  if ($notnull_bool(kind == 20/*TokenKind.ASSIGN*/)) return 0;
-  if ($notnull_bool(kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/)) {
+  if (kind == 20/*TokenKind.ASSIGN*/) return 0;
+  if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
     return kind + (15)/*(ADD - ASSIGN_ADD)*/;
   }
   return -1;
 }
 // ********** Code for lang_Parser **************
 function lang_Parser(source, diet, throwOnIncomplete, optionalSemicolons, startOffset) {
   this.source = source;
   this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
   this.optionalSemicolons = optionalSemicolons;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
 lang_Parser.prototype.isPrematureEndOfFile = function() {
-  if ($notnull_bool(this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/)) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/)) {
+  if ($notnull_bool($notnull_bool($notnull_bool(this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/)) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/)) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/))) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if ($notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
 lang_Parser.prototype._peek = function() {
   return this._peekToken.kind;
 }
 lang_Parser.prototype._lang_next = function() {
   this._previousToken = this._peekToken;
   this._peekToken = this.tokenizer.next();
   return this._previousToken;
 }
 lang_Parser.prototype._peekKind = function(kind) {
   return this._peekToken.kind == kind;
 }
 lang_Parser.prototype._peekIdentifier = function() {
   return TokenKind.isIdentifier(this._peekToken.kind);
 }
 lang_Parser.prototype._maybeEat = function(kind) {
-  if ($notnull_bool(this._peekToken.kind == kind)) {
+  if (this._peekToken.kind == kind) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
 lang_Parser.prototype._eat = function(kind) {
-  if ($notnull_bool(!$notnull_bool(this._maybeEat(kind)))) {
+  if (!$notnull_bool(this._maybeEat(kind))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 lang_Parser.prototype._eatSemicolon = function() {
   if ($notnull_bool(this.optionalSemicolons && this._peekKind(1/*TokenKind.END_OF_FILE*/))) return;
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 lang_Parser.prototype._errorExpected = function(expected) {
   if ($notnull_bool(this.throwOnIncomplete)) this.isPrematureEndOfFile();
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
   this._lang_error($assert_String(message), tok.get$span());
 }
 lang_Parser.prototype._lang_error = function(message, location) {
-  if ($notnull_bool(location == null)) {
+  if (location == null) {
     location = this._peekToken.get$span();
   }
   world.fatal(message, location);
 }
 lang_Parser.prototype._skipBlock = function() {
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
-  while ($notnull_bool(true)) {
+  while (true) {
     var tok = this._lang_next();
     if ($notnull_bool($eq(tok.kind, 6/*TokenKind.LBRACE*/))) {
       depth += 1;
     }
     else if ($notnull_bool($eq(tok.kind, 7/*TokenKind.RBRACE*/))) {
       depth -= 1;
-      if ($notnull_bool(depth == 0)) return;
+      if (depth == 0) return;
     }
     else if ($notnull_bool($eq(tok.kind, 1/*TokenKind.END_OF_FILE*/))) {
       this._lang_error('unexpected end of file during diet parse', tok.get$span());
       return;
     }
   }
 }
 lang_Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add(this.directive());
   }
-  while ($notnull_bool(!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/)))) {
+  while (!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     ret.add(this.topLevelDefinition());
   }
   return (ret && ret.is$List$Definition());
 }
 lang_Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
@@ skipping 38 matching lines @@
   var _native = null;
   if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
     _native = this.maybeStringLiteral();
   }
   var _factory = null;
   if ($notnull_bool(this._maybeEat(75/*TokenKind.FACTORY*/))) {
     _factory = this.type(0);
   }
   var body = [];
   if ($notnull_bool(this._maybeEat(6/*TokenKind.LBRACE*/))) {
-    while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
+    while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
       if ($notnull_bool(this.isPrematureEndOfFile())) break;
       body.add(this.declaration(true));
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
   return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
 lang_Parser.prototype.functionTypeAlias = function() {
@@ skipping 16 matching lines @@
     ret.add(this.expression());
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   this._inInitializers = false;
   return ret;
 }
 lang_Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._maybeEat(9/*TokenKind.ARROW*/))) {
     var expr = this.expression();
-    if ($notnull_bool(!$notnull_bool(inExpression))) {
+    if (!$notnull_bool(inExpression)) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
     if ($notnull_bool(this.diet)) {
       this._skipBlock();
       return new DietStatement(this._makeSpan(start));
     }
     else {
       return this.block();
     }
   }
-  else if ($notnull_bool(!$notnull_bool(inExpression))) {
+  else if (!$notnull_bool(inExpression)) {
     if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
       return null;
     }
     else if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
       var nativeBody = this.maybeStringLiteral();
       if ($notnull_bool(this._peekKind(10/*TokenKind.SEMICOLON*/))) {
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
@@ skipping 69 matching lines @@
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   else if ($notnull_bool(typeParams == null)) {
-    if ($notnull_bool(names.length > 1)) {
+    if (names.length > 1) {
       name = names.removeLast();
     }
     else {
       name = new lang_Identifier('', names.$index(0).get$span());
     }
   }
   else {
     name = new lang_Identifier('', names.$index(0).get$span());
   }
-  if ($notnull_bool(names.length > 1)) {
+  if (names.length > 1) {
     this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 lang_Parser.prototype.statement = function() {
   var $0;
   switch (this._peek()) {
     case 88/*TokenKind.BREAK*/:
@@ skipping 62 matching lines @@
 
   }
 }
 lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
   var $0;
   var start = expr.get$span().start;
   if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
-  if ($notnull_bool((expr instanceof LambdaExpression))) {
-    if ($notnull_bool(!(expr.func.body instanceof BlockStatement))) {
+  if ((expr instanceof LambdaExpression)) {
+    if (!(expr.func.body instanceof BlockStatement)) {
       this._eatSemicolon();
       expr.func.span = this._makeSpan(start);
     }
     return expr.func;
   }
-  else if ($notnull_bool((expr instanceof DeclaredIdentifier))) {
+  else if ((expr instanceof DeclaredIdentifier)) {
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
     return this.finishField(start, null, expr.type, expr.get$name(), value);
   }
   else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
     var di = (($0 = expr.x) && $0.is$DeclaredIdentifier());
     return this.finishField(start, null, di.type, di.name, expr.y);
   }
@@ skipping 16 matching lines @@
 lang_Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return (ret && ret.is$lang_Expression());
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
-  while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
+  while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
 }
 lang_Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
@@ skipping 22 matching lines @@
   this._eat(114/*TokenKind.WHILE*/);
   var test = this.testCondition();
   this._eatSemicolon();
   return new DoStatement(body, test, this._makeSpan(start));
 }
 lang_Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
-  if ($notnull_bool((init instanceof ForInStatement))) {
+  if ((init instanceof ForInStatement)) {
     return init;
   }
   var test = null;
-  if ($notnull_bool(!$notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/)))) {
+  if (!$notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
-  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
+  if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     step.add(this.expression());
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       step.add(this.expression());
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
 lang_Parser.prototype.forInitializerStatement = function(start) {
@@ skipping 51 matching lines @@
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
 lang_Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(107/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
+  while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     cases.add(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
 lang_Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
-  return $notnull_bool($eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 89/*TokenKind.CASE*/)) || $eq(kind, 93/*TokenKind.DEFAULT*/);
+  return $notnull_bool($notnull_bool($eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 89/*TokenKind.CASE*/)) || $eq(kind, 93/*TokenKind.DEFAULT*/));
 }
 lang_Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if ($notnull_bool(this._peekIdentifier())) {
     label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
   }
   var cases = [];
-  while ($notnull_bool(true)) {
+  while (true) {
     if ($notnull_bool(this._maybeEat(89/*TokenKind.CASE*/))) {
       cases.add(this.expression());
       this._eat(8/*TokenKind.COLON*/);
     }
     else if ($notnull_bool(this._maybeEat(93/*TokenKind.DEFAULT*/))) {
       cases.add(null);
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
-  if ($notnull_bool(cases.length == 0)) {
+  if (cases.length == 0) {
     this._lang_error('case or default');
   }
   var stmts = [];
-  while ($notnull_bool(!$notnull_bool(this._peekCaseEnd()))) {
+  while (!$notnull_bool(this._peekCaseEnd())) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
 lang_Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(105/*TokenKind.RETURN*/);
   var expr;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
@@ skipping 44 matching lines @@
   if ($notnull_bool(this._peekIdentifier())) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
 lang_Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
 lang_Parser.prototype._makeType = function(expr) {
-  if ($notnull_bool((expr instanceof VarExpression))) {
+  if ((expr instanceof VarExpression)) {
     return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
   }
-  else if ($notnull_bool((expr instanceof DotExpression))) {
+  else if ((expr instanceof DotExpression)) {
     var type = this._makeType(expr.self);
-    if ($notnull_bool(type.names == null)) {
+    if (type.names == null) {
       type.names = [expr.get$name()];
     }
     else {
       type.names.add(expr.get$name());
     }
     type.span = expr.get$span();
     return type;
   }
   else {
     this._lang_error('expected type reference');
@@ skipping 15 matching lines @@
     var typeParam = this._makeType(x.y);
     var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
     $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 801, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type;
-    if ($notnull_bool(firstParam.depth <= 0)) {
+    if (firstParam.depth <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       type = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
 lang_Parser.prototype.finishInfixExpression = function(x, precedence) {
-  while ($notnull_bool(true)) {
+  while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
-    if ($notnull_bool(prec >= precedence)) {
-      if ($notnull_bool(kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/)) {
+    if (prec >= precedence) {
+      if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
         if ($notnull_bool(this._isBin(x, 52/*TokenKind.LT*/))) {
           return this._fixAsType((x && x.is$BinaryExpression()));
         }
       }
       var op = this._lang_next();
       if ($notnull_bool($eq(op.kind, 102/*TokenKind.IS*/))) {
         var isTrue = !$notnull_bool(this._maybeEat(19/*TokenKind.NOT*/));
         var typeRef = this.type(0);
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
       var y = this.infixExpression($assert_num($notnull_bool($eq(prec, 2)) ? prec : prec + 1));
       if ($notnull_bool($eq(op.kind, 33/*TokenKind.CONDITIONAL*/))) {
         this._eat(8/*TokenKind.COLON*/);
-        var z = this.infixExpression($assert_num(prec + 1));
+        var z = this.infixExpression($assert_num(prec));
         x = new ConditionalExpression(x, y, z, this._makeSpan(x.span.start));
       }
       else {
         x = new BinaryExpression(op, x, y, this._makeSpan(x.span.start));
       }
     }
     else {
       break;
     }
   }
@@ skipping 35 matching lines @@
   expr = this.expression();
   if ($notnull_bool(label == null && this._maybeEat(8/*TokenKind.COLON*/))) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
 lang_Parser.prototype.arguments = function() {
   var args = [];
   this._eat(2/*TokenKind.LPAREN*/);
-  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
+  if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     do {
       args.add(this.argument());
     }
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
 lang_Parser.prototype.get$arguments = function() {
   return lang_Parser.prototype.arguments.bind(this);
@@ skipping 36 matching lines @@
       if ($notnull_bool(this._peekIdentifier())) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
 lang_Parser.prototype._isBin = function(expr, kind) {
-  return $notnull_bool((expr instanceof BinaryExpression) && expr.op.kind == kind);
+  return (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
-  return new TypeReference(span, world.boolType);
+  return new TypeReference(span, world.nonNullBool);
 }
 lang_Parser.prototype._intTypeRef = function(span) {
   return new TypeReference(span, world.intType);
 }
 lang_Parser.prototype._doubleTypeRef = function(span) {
   return new TypeReference(span, world.doubleType);
 }
 lang_Parser.prototype._stringTypeRef = function(span) {
   return new TypeReference(span, world.stringType);
 }
@@ skipping 87 matching lines @@
       return this.finishTypedLiteral(start, false);
 
     case 113/*TokenKind.VOID*/:
     case 112/*TokenKind.VAR*/:
     case 97/*TokenKind.FINAL*/:
 
       return this.declaredIdentifier(false);
 
     default:
 
-      if ($notnull_bool(!$notnull_bool(this._peekIdentifier()))) {
+      if (!$notnull_bool(this._peekIdentifier())) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 lang_Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
@@ skipping 50 matching lines @@
   }
   else if ($notnull_bool($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
-  if ($notnull_bool(!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))))) {
+  if (!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/)))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
-    if ($notnull_bool(args.length == 1)) {
+    if (args.length == 1) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
       this._lang_error('unexpected comma expression');
       return args.$index(0).get$value();
     }
   }
 }
 lang_Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
@@ skipping 11 matching lines @@
 
     case 108/*TokenKind.THIS*/:
 
       this._eat(108/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name() + '');
       break;
 
     case 76/*TokenKind.GET*/:
 
-      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
+      if (!$notnull_bool(includeOperators)) return null;
       this._eat(76/*TokenKind.GET*/);
       if ($notnull_bool(this._peekIdentifier())) {
         name = ('get\$' + this.identifier().get$name() + '');
       }
       else {
         name = 'get';
       }
       break;
 
     case 84/*TokenKind.SET*/:
 
-      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
+      if (!$notnull_bool(includeOperators)) return null;
       this._eat(84/*TokenKind.SET*/);
       if ($notnull_bool(this._peekIdentifier())) {
         name = ('set\$' + this.identifier().get$name() + '');
       }
       else {
         name = 'set';
       }
       break;
 
     case 83/*TokenKind.OPERATOR*/:
 
-      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
+      if (!$notnull_bool(includeOperators)) return null;
       this._eat(83/*TokenKind.OPERATOR*/);
       var kind = this._peek();
       if ($notnull_bool($eq(kind, 82/*TokenKind.NEGATE*/))) {
         name = '\$negate';
         this._lang_next();
       }
       else {
         name = TokenKind.binaryMethodName($assert_num(kind));
-        if ($notnull_bool(name == null)) {
+        if (name == null) {
           name = 'operator';
         }
         else {
           this._lang_next();
         }
       }
       break;
 
     default:
 
       return null;
 
   }
   return new lang_Identifier(name, this._makeSpan(start));
 }
 lang_Parser.prototype.declaredIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var myType = null;
   var name = this._specialIdentifier(includeOperators);
-  if ($notnull_bool(name == null)) {
+  if (name == null) {
     myType = this.type(0);
     name = this._specialIdentifier(includeOperators);
-    if ($notnull_bool(name == null)) {
+    if (name == null) {
       if ($notnull_bool(this._peekIdentifier())) {
         name = this.identifier();
       }
-      else if ($notnull_bool((myType instanceof NameTypeReference) && myType.names == null)) {
+      else if ((myType instanceof NameTypeReference) && myType.names == null) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
 lang_Parser._hexDigit = function(c) {
-  if ($notnull_bool(c >= 48 && c <= 57)) {
+  if (c >= 48 && c <= 57) {
     return c - 48;
   }
-  else if ($notnull_bool(c >= 97 && c <= 102)) {
+  else if (c >= 97 && c <= 102) {
     return c - 87;
   }
-  else if ($notnull_bool(c >= 65 && c <= 70)) {
+  else if (c >= 65 && c <= 70) {
     return c - 55;
   }
   else {
     return -1;
   }
 }
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
-   $notnull_bool(i < hex.length); i++) {
+   i < hex.length; i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
-    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1257, 14);
+    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1259, 14);
     result = (result << 4) + $assert_num(digit);
   }
   return $assert_num(result);
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   var args = this.arguments();
   return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.finishListLiteral = function(start, isConst, type) {
   if ($notnull_bool(this._maybeEat(56/*TokenKind.INDEX*/))) {
     return new ListExpression(isConst, type, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
-  while ($notnull_bool(!$notnull_bool(this._maybeEat(5/*TokenKind.RBRACK*/)))) {
+  while (!$notnull_bool(this._maybeEat(5/*TokenKind.RBRACK*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     values.add(this.expression());
-    if ($notnull_bool(!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))) {
+    if (!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type, values, this._makeSpan(start));
 }
 lang_Parser.prototype.finishMapLiteral = function(start, isConst, type) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
+  while (!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     items.add(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add(this.expression());
-    if ($notnull_bool(!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))) {
+    if (!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type, items, this._makeSpan(start));
 }
 lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, (span && span.is$SourceSpan()));
   var genericType = this.addTypeArguments((typeToBeNamedLater && typeToBeNamedLater.is$TypeReference()), 0);
   if ($notnull_bool(this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/))) {
     return this.finishListLiteral(start, isConst, (genericType && genericType.is$TypeReference()));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
     return this.finishMapLiteral(start, isConst, (genericType && genericType.is$TypeReference()));
   }
   else {
     this._errorExpected('array or map literal');
   }
 }
 lang_Parser.prototype._readModifiers = function() {
   var modifiers = null;
-  while ($notnull_bool(true)) {
+  while (true) {
     switch (this._peek()) {
       case 86/*TokenKind.STATIC*/:
       case 97/*TokenKind.FINAL*/:
       case 91/*TokenKind.CONST*/:
       case 71/*TokenKind.ABSTRACT*/:
       case 75/*TokenKind.FACTORY*/:
 
-        if ($notnull_bool(modifiers == null)) modifiers = [];
+        if (modifiers == null) modifiers = [];
         modifiers.add(this._lang_next());
         break;
 
       default:
 
         return modifiers;
 
     }
   }
   return null;
 }
 lang_Parser.prototype.typeParameter = function() {
   var start = this._peekToken.start;
   var name = this.identifier();
   var myType = null;
   if ($notnull_bool(this._maybeEat(74/*TokenKind.EXTENDS*/))) {
     myType = this.type(1);
   }
   return new TypeParameter(name, myType, this._makeSpan(start));
 }
 lang_Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add(tp);
-    if ($notnull_bool((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0)) {
+    if ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
       closed = true;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
-  if ($notnull_bool(!$notnull_bool(closed))) {
+  if (!$notnull_bool(closed)) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
 lang_Parser.prototype.get$typeParameters = function() {
   return lang_Parser.prototype.typeParameters.bind(this);
 }
 lang_Parser.prototype._eatClosingAngle = function(depth) {
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     return depth;
@@ skipping 11 matching lines @@
 }
 lang_Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat(52/*TokenKind.LT*/);
   return this._finishTypeArguments(baseType, depth, []);
 }
 lang_Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
   var delta = -1;
   do {
     var myType = this.type(depth + 1);
     types.add(myType);
-    if ($notnull_bool((myType instanceof GenericTypeReference) && myType.depth <= depth)) {
+    if ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
       delta = depth - myType.depth;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
-  if ($notnull_bool(delta >= 0)) {
+  if (delta >= 0) {
     depth -= $assert_num(delta);
   }
   else {
     depth = this._eatClosingAngle(depth);
   }
   var span = this._makeSpan(baseType.span.start);
   return new GenericTypeReference(baseType, types, depth, (span && span.is$SourceSpan()));
 }
 lang_Parser.prototype.typeList = function() {
   var types = [];
@@ skipping 25 matching lines @@
       name = this.identifier();
       break;
 
     default:
 
       name = this.identifier();
       break;
 
   }
   while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
-    if ($notnull_bool(names == null)) names = [];
+    if (names == null) names = [];
     names.add(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     return this.addTypeArguments((typeRef && typeRef.is$TypeReference()), depth);
   }
   else {
     return typeRef;
   }
 }
 lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type = di.type;
   var name = di.get$name();
   var value = null;
   if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
-    if ($notnull_bool(!$notnull_bool(inOptionalBlock))) {
+    if (!$notnull_bool(inOptionalBlock)) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if ($notnull_bool(this._peekKind(2/*TokenKind.LPAREN*/))) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if ($notnull_bool(inOptionalBlock && value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
-  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
+  if (!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/))) {
     if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
       inOptionalBlock = true;
     }
     formals.add(this.formalParameter($assert_bool(inOptionalBlock)));
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
         if ($notnull_bool(inOptionalBlock)) {
           this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add(this.formalParameter($assert_bool(inOptionalBlock)));
     }
     if ($notnull_bool(inOptionalBlock)) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
 lang_Parser.prototype.identifier = function() {
   var tok = this._lang_next();
-  if ($notnull_bool(!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.kind))))) {
+  if (!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.kind)))) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
   return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
 lang_Parser.prototype._makeFunction = function(expr, body) {
   var name, type;
-  if ($notnull_bool((expr instanceof CallExpression))) {
-    if ($notnull_bool((expr.target instanceof VarExpression))) {
+  if ((expr instanceof CallExpression)) {
+    if ((expr.target instanceof VarExpression)) {
       name = expr.target.get$name();
       type = null;
     }
-    else if ($notnull_bool((expr.target instanceof DeclaredIdentifier))) {
+    else if ((expr.target instanceof DeclaredIdentifier)) {
       name = expr.target.get$name();
       type = expr.target.type;
     }
     else {
       this._lang_error('bad function');
     }
     var formals = this._makeFormals(expr.get$arguments());
     var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
     var func = new FunctionDefinition(null, type, name, formals, null, body, (span && span.is$SourceSpan()));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._lang_error('expected function');
   }
 }
 lang_Parser.prototype._makeFormal = function(expr) {
   var $0;
-  if ($notnull_bool((expr instanceof VarExpression))) {
+  if ((expr instanceof VarExpression)) {
     return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
   }
-  else if ($notnull_bool((expr instanceof DeclaredIdentifier))) {
+  else if ((expr instanceof DeclaredIdentifier)) {
     return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
   }
   else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
     var di = (($0 = expr.x) && $0.is$DeclaredIdentifier());
     return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
   }
   else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/))) {
     return null;
   }
-  else if ($notnull_bool((expr instanceof ListExpression))) {
+  else if ((expr instanceof ListExpression)) {
     return this._makeFormalsFromList(expr);
   }
   else {
     this._lang_error('expected formal', expr.get$span());
   }
 }
 lang_Parser.prototype._makeFormalsFromList = function(expr) {
   if ($notnull_bool(expr.get$isConst())) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
   else if ($notnull_bool($ne(expr.type, null))) {
     this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
   }
   return this._makeFormalsFromExpressions(expr.values, false);
 }
 lang_Parser.prototype._makeFormals = function(arguments) {
   var expressions = [];
   for (var i = 0;
-   $notnull_bool(i < arguments.length); i++) {
+   i < arguments.length; i++) {
     var arg = arguments.$index(i);
-    if ($notnull_bool(arg.label != null)) {
+    if (arg.label != null) {
       this._lang_error('expected formal, but found ":"');
     }
     expressions.add(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
 lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var $0;
   var formals = [];
   for (var i = 0;
-   $notnull_bool(i < expressions.length); i++) {
+   i < expressions.length; i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if ($notnull_bool(formal == null)) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
-      while ($notnull_bool(i < expressions.length)) {
+      while (i < expressions.length) {
         var expr = expressions.$index(i++);
         if ($notnull_bool(this._isBin(expr, 53/*TokenKind.GT*/))) {
           typeParams.add(this._makeType(expr.x));
           var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
           var name = null;
-          if ($notnull_bool((expr.y instanceof VarExpression))) {
+          if ((expr.y instanceof VarExpression)) {
             var ve = (($0 = expr.y) && $0.is$VarExpression());
             name = ve.name;
           }
           else {
             this._lang_error('expected formal', expr.get$span());
           }
           formal = new FormalNode(false, false, type, name, null, this._makeSpan(expressions.$index(0).get$span().start));
           break;
         }
         else {
           typeParams.add(this._makeType(expr));
         }
       }
       formals.add(formal);
     }
-    else if ($notnull_bool(!!(formal && formal.is$List))) {
+    else if (!!(formal && formal.is$List)) {
       formals.addAll(formal);
-      if ($notnull_bool(!$notnull_bool(allowOptional))) {
+      if (!$notnull_bool(allowOptional)) {
         this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
       }
     }
     else {
       formals.add(formal);
     }
   }
   return formals;
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
-  if ($notnull_bool((e instanceof VarExpression))) {
+  if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
-  else if ($notnull_bool((e instanceof DeclaredIdentifier))) {
+  else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
     this._lang_error('expected declared identifier');
     return new DeclaredIdentifier(null, null, e.get$span());
   }
 }
 lang_Parser.prototype._makeLabel = function(expr) {
-  if ($notnull_bool((expr instanceof VarExpression))) {
+  if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
 // ********** Code for IncompleteSourceException **************
 function IncompleteSourceException(token) {
   this.token = token;
   // Initializers done
 }
 IncompleteSourceException.prototype.toString = function() {
-  if ($notnull_bool(this.token.get$span() == null)) return ('Unexpected ' + this.token + '');
+  if (this.token.get$span() == null) return ('Unexpected ' + this.token + '');
   return $assert_String(this.token.get$span().toMessageString(('Unexpected ' + this.token + '')));
 }
 // ********** Code for lang_Node **************
 function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
 lang_Node.prototype.is$lang_Node = function(){return this;};
 lang_Node.prototype.get$span = function() { return this.span; };
 lang_Node.prototype.set$span = function(value) { return this.span = value; };
@@ skipping 687 matching lines @@
   // Initializers done
 }
 lang_Type.prototype.is$lang_Type = function(){return this;};
 lang_Type.prototype.is$Named = function(){return this;};
 lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
   var $0;
-  if ($notnull_bool(this._typeMember == null)) {
+  if (this._typeMember == null) {
     this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
   return (($0 = this._typeMember) && $0.is$TypeMember());
 }
 lang_Type.prototype.getMember = function(name) {
   return null;
 }
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
@@ skipping 21 matching lines @@
 lang_Type.prototype.get$isVoid = function() {
   return false;
 }
 lang_Type.prototype.get$isVarOrFunction = function() {
   return $notnull_bool(this.get$isVar() || this.get$isFunction());
 }
 lang_Type.prototype.getCallMethod = function() {
   return null;
 }
 lang_Type.prototype.get$isClosed = function() {
-  return $notnull_bool(this.get$isString() || this.get$isBool()) || this.get$isNum() || this.get$isFunction() || this.get$isVar();
+  return $notnull_bool($notnull_bool($notnull_bool($notnull_bool(this.get$isString() || this.get$isBool()) || this.get$isNum()) || this.get$isFunction()) || this.get$isVar());
 }
 lang_Type.prototype.get$isUsed = function() {
   return false;
 }
 lang_Type.prototype.get$isGeneric = function() {
   return false;
 }
 lang_Type.prototype.get$isNativeType = function() {
   return false;
 }
 lang_Type.prototype.get$isNative = function() {
   return this.get$isNativeType();
 }
 lang_Type.prototype.get$hasTypeParams = function() {
   return false;
 }
 lang_Type.prototype.get$typeofName = function() {
   return null;
 }
 lang_Type.prototype.get$jsname = function() {
-  return $notnull_bool(this._jsname == null) ? this.name : this._jsname;
+  return this._jsname == null ? this.name : this._jsname;
 }
 lang_Type.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
 lang_Type.prototype.get$members = function() {
   return null;
 }
 lang_Type.prototype.get$definition = function() {
   return null;
 }
@@ skipping 12 matching lines @@
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
 lang_Type.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 lang_Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
-  if ($notnull_bool(!$notnull_bool(this.isSubtypeOf(other)))) {
+  if (!$notnull_bool(this.isSubtypeOf(other))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name + '');
     if ($notnull_bool(typeErrors)) {
       world.error($assert_String(msg), span);
     }
     else {
       world.warning($assert_String(msg), span);
     }
   }
 }
 lang_Type.prototype.needsVarCall = function(args) {
   if ($notnull_bool(this.get$isVarOrFunction())) {
     return true;
   }
   var call = this.getCallMethod();
   if ($notnull_bool($ne(call, null))) {
-    if ($notnull_bool(args.get$length() != call.get$parameters().length || !$notnull_bool(call.namesInOrder(args)))) {
+    if (args.get$length() != call.get$parameters().length || !$notnull_bool(call.namesInOrder(args))) {
       return true;
     }
   }
   return false;
 }
 lang_Type.union = function(x, y) {
-  if ($notnull_bool($eq(x, y))) return x;
+  if ($eq(x, y)) return x;
   if ($notnull_bool(x.get$isNum() && y.get$isNum())) return world.numType;
   if ($notnull_bool(x.get$isString() && y.get$isString())) return world.stringType;
   return world.varType;
 }
 lang_Type.prototype.isAssignable = function(other) {
   return $notnull_bool(this.isSubtypeOf(other) || other.isSubtypeOf(this));
 }
 lang_Type.prototype._isDirectSupertypeOf = function(other) {
   var $this = this; // closure support
   if ($notnull_bool(other.get$isClass())) {
-    return $notnull_bool($eq(other.get$parent(), this) || $notnull_bool(this.get$isObject() && other.get$parent() == null));
+    return $eq(other.get$parent(), this) || $notnull_bool(this.get$isObject() && other.get$parent() == null);
   }
   else {
-    if ($notnull_bool(other.get$interfaces() == null || other.get$interfaces().isEmpty())) {
+    if (other.get$interfaces() == null || other.get$interfaces().isEmpty()) {
       return this.get$isObject();
     }
     else {
       return other.get$interfaces().some((function (i) {
         return $eq(i, $this);
       })
       );
     }
   }
 }
 lang_Type.prototype.isSubtypeOf = function(other) {
-  if ($notnull_bool((other instanceof ParameterType))) {
+  if ((other instanceof ParameterType)) {
     return true;
   }
-  if ($notnull_bool($eq(this, other))) return true;
+  if ($eq(this, other)) return true;
   if ($notnull_bool(this.get$isVar())) return true;
   if ($notnull_bool(other.get$isVar())) return true;
   if ($notnull_bool(other._isDirectSupertypeOf(this))) return true;
   var call = this.getCallMethod();
   var otherCall = other.getCallMethod();
   if ($notnull_bool($ne(call, null) && $ne(otherCall, null))) {
     return lang_Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
   }
-  if ($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null)) && $ne(other.get$typeArgsInOrder(), null) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length) {
+  if ($notnull_bool($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null)) && $ne(other.get$typeArgsInOrder(), null)) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length) {
     var t = this.get$typeArgsInOrder().iterator();
     var s = other.get$typeArgsInOrder().iterator();
     while ($notnull_bool(t.hasNext())) {
-      if ($notnull_bool(!$notnull_bool(t.next().isSubtypeOf(s.next())))) return false;
+      if (!$notnull_bool(t.next().isSubtypeOf(s.next()))) return false;
     }
     return true;
   }
   if ($notnull_bool(this.get$parent() != null && this.get$parent().isSubtypeOf(other))) {
     return true;
   }
-  if ($notnull_bool(this.get$interfaces() != null && this.get$interfaces().some((function (i) {
+  if (this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf(other);
   })
-  ))) {
+  )) {
     return true;
   }
   return false;
 }
 lang_Type._isFunctionSubtypeOf = function(t, s) {
   var $0;
-  if ($notnull_bool(!$notnull_bool(s.returnType.get$isVoid()) && !$notnull_bool(s.returnType.isAssignable(t.returnType)))) {
+  if (!$notnull_bool(s.returnType.get$isVoid()) && !$notnull_bool(s.returnType.isAssignable(t.returnType))) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
-  if ($notnull_bool(tp.length < sp.length)) return false;
+  if (tp.length < sp.length) return false;
   for (var i = 0;
-   $notnull_bool(i < sp.length); i++) {
-    if ($notnull_bool($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional()))) return false;
+   i < sp.length; i++) {
+    if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
     if ($notnull_bool(tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name()))) return false;
-    if ($notnull_bool(!$notnull_bool(tp.$index(i).type.isAssignable((($0 = sp.$index(i).type) && $0.is$lang_Type()))))) return false;
+    if (!$notnull_bool(tp.$index(i).type.isAssignable((($0 = sp.$index(i).type) && $0.is$lang_Type())))) return false;
   }
-  if ($notnull_bool(tp.length > sp.length && !$notnull_bool(tp.$index(sp.length).get$isOptional()))) return false;
+  if (tp.length > sp.length && !$notnull_bool(tp.$index(sp.length).get$isOptional())) return false;
   return true;
 }
 // ********** Code for ParameterType **************
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
   lang_Type.call(this, name);
   // Initializers done
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.is$ParameterType = function(){return this;};
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.get$constructors = function() {
   world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.getCallMethod = function() {
   return this.extendsType.getCallMethod();
 }
 ParameterType.prototype.genMethod = function(method) {
   this.extendsType.genMethod(method);
 }
-ParameterType.prototype.isSubtypeOf = function(child) {
+ParameterType.prototype.isSubtypeOf = function(other) {
   return true;
 }
 ParameterType.prototype.resolveMember = function(memberName) {
   return this.extendsType.resolveMember(memberName);
 }
 ParameterType.prototype.getConstructor = function(constructorName) {
   world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
   world.internalError('no concrete types of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
   var $0;
   return (($0 = inType.typeArguments.$index(this.name)) && $0.is$lang_Type());
 }
 ParameterType.prototype.addDirectSubtype = function(type) {
   world.internalError('no subtypes of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolve = function(inType) {
-  if ($notnull_bool(this.typeParameter.extendsType != null)) {
+  if (this.typeParameter.extendsType != null) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
   }
 }
+// ********** Code for NonNullableType **************
+function NonNullableType(type) {
+  this.type = type;
+  lang_Type.call(this, type.name);
+  // Initializers done
+}
+$inherits(NonNullableType, lang_Type);
+NonNullableType.prototype.get$isBool = function() {
+  return this.type.get$isBool();
+}
+NonNullableType.prototype.get$isUsed = function() {
+  return false;
+}
+NonNullableType.prototype.isSubtypeOf = function(other) {
+  return $notnull_bool($eq(this, other) || $eq(this.type, other) || this.type.isSubtypeOf(other));
+}
+NonNullableType.prototype.resolveType = function(node, isRequired) {
+  return this.type.resolveType(node, isRequired);
+}
+NonNullableType.prototype.resolveTypeParams = function(inType) {
+  return this.type.resolveTypeParams(inType);
+}
+NonNullableType.prototype.addDirectSubtype = function(subtype) {
+  this.type.addDirectSubtype(subtype);
+}
+NonNullableType.prototype.markUsed = function() {
+  this.type.markUsed();
+}
+NonNullableType.prototype.genMethod = function(method) {
+  this.type.genMethod(method);
+}
+NonNullableType.prototype.get$span = function() {
+  return this.type.get$span();
+}
+NonNullableType.prototype.resolveMember = function(name) {
+  return this.type.resolveMember(name);
+}
+NonNullableType.prototype.getMember = function(name) {
+  return this.type.getMember(name);
+}
+NonNullableType.prototype.getConstructor = function(name) {
+  var $0;
+  return (($0 = this.type.getConstructor(name)) && $0.is$MethodMember());
+}
+NonNullableType.prototype.getFactory = function(t, name) {
+  var $0;
+  return (($0 = this.type.getFactory(t, name)) && $0.is$MethodMember());
+}
+NonNullableType.prototype.getOrMakeConcreteType = function(typeArgs) {
+  return this.type.getOrMakeConcreteType(typeArgs);
+}
+NonNullableType.prototype.get$constructors = function() {
+  return this.type.get$constructors();
+}
+NonNullableType.prototype.get$isClass = function() {
+  return this.type.get$isClass();
+}
+NonNullableType.prototype.get$library = function() {
+  return this.type.get$library();
+}
+NonNullableType.prototype.getCallMethod = function() {
+  return this.type.getCallMethod();
+}
+NonNullableType.prototype.get$isGeneric = function() {
+  return this.type.get$isGeneric();
+}
+NonNullableType.prototype.get$hasTypeParams = function() {
+  return this.type.get$hasTypeParams();
+}
+NonNullableType.prototype.get$typeofName = function() {
+  return this.type.get$typeofName();
+}
+NonNullableType.prototype.get$jsname = function() {
+  return this.type.get$jsname();
+}
+NonNullableType.prototype.set$jsname = function(name) {
+  return this.type.set$jsname(name);
+}
+NonNullableType.prototype.get$members = function() {
+  return this.type.get$members();
+}
+NonNullableType.prototype.get$definition = function() {
+  return this.type.get$definition();
+}
+NonNullableType.prototype.get$factories = function() {
+  return this.type.get$factories();
+}
+NonNullableType.prototype.get$typeArgsInOrder = function() {
+  var $0;
+  return (($0 = this.type.get$typeArgsInOrder()) && $0.is$Collection$Type());
+}
+NonNullableType.prototype.get$genericType = function() {
+  return this.type.get$genericType();
+}
+NonNullableType.prototype.get$interfaces = function() {
+  return this.type.get$interfaces();
+}
+NonNullableType.prototype.get$parent = function() {
+  return this.type.get$parent();
+}
+NonNullableType.prototype.getAllMembers = function() {
+  return this.type.getAllMembers();
+}
+NonNullableType.prototype.get$isNativeType = function() {
+  return this.type.get$isNativeType();
+}
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   lang_Type.call(this, name);
   // Initializers done
 }
 $inherits(ConcreteType, lang_Type);
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.library;
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
-  return this.typeArguments.getValues().some((function (e) {
+  return $assert_bool(this.typeArguments.getValues().some((function (e) {
     return (e instanceof ParameterType);
   })
-  );
+  ));
 }
 ConcreteType.prototype.get$members = function() { return this.members; };
 ConcreteType.prototype.set$members = function(value) { return this.members = value; };
 ConcreteType.prototype.get$constructors = function() { return this.constructors; };
 ConcreteType.prototype.set$constructors = function(value) { return this.constructors = value; };
 ConcreteType.prototype.get$factories = function() { return this.factories; };
 ConcreteType.prototype.set$factories = function(value) { return this.factories = value; };
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   var newTypeArgs = [];
   var needsNewType = false;
   var $list = this.typeArgsInOrder;
   for (var $i = 0;$i < $list.length; $i++) {
     var t = $list.$index($i);
     var newType = t.resolveTypeParams(inType);
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add(newType);
   }
-  if ($notnull_bool(!$notnull_bool(needsNewType))) return this;
+  if (!$notnull_bool(needsNewType)) return this;
   return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List$Type()));
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
   return this.genericType.get$parent();
 }
 ConcreteType.prototype.get$interfaces = function() {
-  if ($notnull_bool(this._interfaces == null && this.genericType.interfaces != null)) {
+  if (this._interfaces == null && this.genericType.interfaces != null) {
     this._interfaces = [];
     var $list = this.genericType.interfaces;
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams(this));
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.getCallMethod = function() {
@@ skipping 20 matching lines @@
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
   if ($notnull_bool(genericMember == null)) return null;
-  if ($notnull_bool($ne(genericMember.declaringType, this.genericType))) {
-    if ($notnull_bool(!$notnull_bool(genericMember.declaringType.get$isGeneric()))) return genericMember;
+  if ($ne(genericMember.declaringType, this.genericType)) {
+    if (!$notnull_bool(genericMember.declaringType.get$isGeneric())) return genericMember;
     var newDeclaringType = genericMember.declaringType.getOrMakeConcreteType(this.typeArgsInOrder);
     return newDeclaringType.getConstructor(constructorName);
   }
   if ($notnull_bool(genericMember.get$isFactory())) {
     ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
     this.factories.addFactory(this.name, constructorName, (ret && ret.is$Member()));
   }
   else {
     ret = new ConcreteMember(this.name, this, genericMember);
     this.constructors.$setindex(constructorName, ret);
@@ skipping 64 matching lines @@
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 564, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 628, 12);
   this.definition = def;
-  if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null)) {
+  if ((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null) {
     this.isNativeType = true;
   }
-  if ($notnull_bool(this.definition != null && this.definition.get$typeParameters() != null)) {
+  if (this.definition != null && this.definition.get$typeParameters() != null) {
     this._concreteTypes = $map([]);
     this.typeParameters = [];
     var $list = this.definition.get$typeParameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
       var paramName = tp.get$name().get$name();
       this.typeParameters.add(new ParameterType($assert_String(paramName), tp));
     }
   }
 }
 DefinedType.prototype.get$typeArgsInOrder = function() {
-  if ($notnull_bool(this.typeParameters == null)) return null;
-  if ($notnull_bool(this._typeArgsInOrder == null)) {
+  if (this.typeParameters == null) return null;
+  if (this._typeArgsInOrder == null) {
     this._typeArgsInOrder = new FixedCollection$Type(world.varType, this.typeParameters.length);
   }
   return this._typeArgsInOrder;
 }
 DefinedType.prototype.get$isVar = function() {
   return $eq(this, world.varType);
 }
 DefinedType.prototype.get$isVoid = function() {
   return $eq(this, world.voidType);
 }
@@ skipping 13 matching lines @@
   return $notnull_bool(this.library.get$isCore() && this.name == 'Function');
 }
 DefinedType.prototype.get$isList = function() {
   return $notnull_bool(this.library.get$isCore() && this.name == 'List');
 }
 DefinedType.prototype.get$isGeneric = function() {
   return this.typeParameters != null;
 }
 DefinedType.prototype.get$span = function() {
   var $0;
-  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
+  return (($0 = this.definition == null ? null : this.definition.span) && $0.is$SourceSpan());
 }
 DefinedType.prototype.get$typeofName = function() {
-  if ($notnull_bool(!$notnull_bool(this.library.get$isCore()))) return null;
+  if (!$notnull_bool(this.library.get$isCore())) return null;
   if ($notnull_bool(this.get$isBool())) return 'boolean';
   else if ($notnull_bool(this.get$isNum())) return 'number';
   else if ($notnull_bool(this.get$isString())) return 'string';
   else if ($notnull_bool(this.get$isFunction())) return 'function';
   else return null;
 }
 DefinedType.prototype.get$isNum = function() {
-  return $notnull_bool(this.library != null && this.library.get$isCore()) && ($notnull_bool(this.name == 'num' || this.name == 'int') || this.name == 'double');
+  return $notnull_bool(this.library != null && this.library.get$isCore()) && (this.name == 'num' || this.name == 'int' || this.name == 'double');
 }
 DefinedType.prototype.getCallMethod = function() {
   var $0;
   return (($0 = this.members.$index('\$call')) && $0.is$MethodMember());
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if ($notnull_bool(this.isUsed)) return;
   this.isUsed = true;
-  if ($notnull_bool(this._lazyGenMethods != null)) {
+  if (this._lazyGenMethods != null) {
     var $list = orderValuesByKeys(this._lazyGenMethods);
     for (var $i = 0;$i < $list.length; $i++) {
       var method = $list.$index($i);
       world.gen.genMethod((method && method.is$Member()));
     }
     this._lazyGenMethods = null;
   }
-  if ($notnull_bool(this.get$parent() != null)) this.get$parent().markUsed();
+  if (this.get$parent() != null) this.get$parent().markUsed();
 }
 DefinedType.prototype.genMethod = function(method) {
   if ($notnull_bool(this.isUsed)) {
     world.gen.genMethod(method);
   }
   else if ($notnull_bool(this.isClass)) {
-    if ($notnull_bool(this._lazyGenMethods == null)) this._lazyGenMethods = $map([]);
+    if (this._lazyGenMethods == null) this._lazyGenMethods = $map([]);
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
-  if ($notnull_bool(types == null)) return [];
+  if (types == null) return [];
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
-    if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool(($notnull_bool(this.library.get$isCore() || this.library.get$isCoreImpl()))))) {
+    if ($notnull_bool(resolvedInterface.get$isClosed() && !($notnull_bool(this.library.get$isCore() || this.library.get$isCoreImpl())))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
     interfaces.add(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 680, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 744, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
-  if ($notnull_bool(this._subtypes == null)) {
+  if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation$Type();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext(); ) {
       var st = $i.next();
       this._subtypes.add(st);
       this._subtypes.addAll(st.get$subtypes());
     }
   }
   return this._subtypes;
 }
 DefinedType.prototype._cycleInClassExtends = function() {
   var seen = new HashSetImplementation();
   seen.add(this);
   var ancestor = this.get$parent();
   while ($notnull_bool($ne(ancestor, null))) {
-    if ($notnull_bool(ancestor === this)) {
+    if (ancestor === this) {
       return true;
     }
-    if ($notnull_bool(seen.contains(ancestor))) {
+    if (seen.contains(ancestor)) {
       return false;
     }
     seen.add(ancestor);
     ancestor = ancestor.get$parent();
   }
   return false;
 }
 DefinedType.prototype._cycleInInterfaceExtends = function() {
   var $this = this; // closure support
   var seen = new HashSetImplementation();
   seen.add(this);
   function _helper(ancestor) {
     if ($notnull_bool(ancestor == null)) return false;
-    if ($notnull_bool(ancestor === $this)) return true;
-    if ($notnull_bool(seen.contains(ancestor))) {
+    if (ancestor === $this) return true;
+    if (seen.contains(ancestor)) {
       return false;
     }
     seen.add(ancestor);
     if ($notnull_bool($ne(ancestor.get$interfaces(), null))) {
       var $list = ancestor.get$interfaces();
       for (var $i = ancestor.get$interfaces().iterator(); $i.hasNext(); ) {
         var parent = $i.next();
         if ($notnull_bool(_helper(parent))) return true;
       }
     }
     return false;
   }
   for (var i = 0;
-   $notnull_bool(i < this.interfaces.length); i++) {
+   i < this.interfaces.length; i++) {
     if ($notnull_bool(_helper(this.interfaces.$index(i)))) return i;
   }
   return -1;
 }
 DefinedType.prototype.resolve = function() {
   var $this = this; // closure support
   var $0;
-  if ($notnull_bool((this.definition instanceof TypeDefinition))) {
+  if ((this.definition instanceof TypeDefinition)) {
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     if ($notnull_bool(this.isClass)) {
-      if ($notnull_bool(typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0)) {
-        if ($notnull_bool(typeDef.extendsTypes.length > 1)) {
+      if (typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0) {
+        if (typeDef.extendsTypes.length > 1) {
           world.error('more than one base class', typeDef.extendsTypes.$index(1).get$span());
         }
         var extendsTypeRef = typeDef.extendsTypes.$index(0);
-        if ($notnull_bool((extendsTypeRef instanceof GenericTypeReference))) {
+        if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = (extendsTypeRef && extendsTypeRef.is$GenericTypeReference());
           this.set$parent(this.resolveType(g.baseType, true));
         }
         this.set$parent(this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true));
-        if ($notnull_bool(!$notnull_bool(this.get$parent().get$isClass()))) {
+        if (!$notnull_bool(this.get$parent().get$isClass())) {
           world.error('class may not extend an interface - use implements', typeDef.extendsTypes.$index(0).get$span());
         }
         this.get$parent().addDirectSubtype(this);
         if ($notnull_bool(this._cycleInClassExtends())) {
           world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
         }
       }
       else {
-        if ($notnull_bool(!$notnull_bool(this.get$isObject()))) {
+        if (!$notnull_bool(this.get$isObject())) {
           this.set$parent(world.objectType);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
-      if ($notnull_bool(typeDef.factoryType != null)) {
+      if (typeDef.factoryType != null) {
         world.error('factory not allowed on classes', typeDef.factoryType.span);
       }
     }
     else {
-      if ($notnull_bool(typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0)) {
+      if (typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0) {
         world.error('implements not allowed on interfaces (use extends)', typeDef.implementsTypes.$index(0).get$span());
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
-      if ($notnull_bool(res >= 0)) {
+      if (res >= 0) {
         world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), typeDef.extendsTypes.$index(res).get$span());
       }
-      if ($notnull_bool(typeDef.factoryType != null)) {
+      if (typeDef.factoryType != null) {
         this.factory_ = this.resolveType(typeDef.factoryType, true);
-        if ($notnull_bool(this.factory_ == null)) {
+        if (this.factory_ == null) {
           world.warning('unresolved factory', typeDef.factoryType.span);
         }
       }
     }
   }
-  else if ($notnull_bool((this.definition instanceof FunctionTypeDefinition))) {
+  else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [world.functionType];
   }
-  if ($notnull_bool(this.typeParameters != null)) {
+  if (this.typeParameters != null) {
     var $list = this.typeParameters;
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
       tp.resolve(this);
     }
   }
   world._addType(this);
   var $list = this.constructors.getValues();
   for (var $i = this.constructors.getValues().iterator(); $i.hasNext(); ) {
     var c = $i.next();
     c.resolve(this);
   }
   var $list0 = this.members.getValues();
   for (var $i = this.members.getValues().iterator(); $i.hasNext(); ) {
     var m = $i.next();
     m.resolve(this);
   }
   this.factories.forEach((function (f) {
     return f.resolve($this);
   })
   );
 }
 DefinedType.prototype.addMethod = function(methodName, definition) {
-  if ($notnull_bool(methodName == null)) methodName = definition.name.name;
+  if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if ($notnull_bool(method.get$isConstructor())) {
-    if ($notnull_bool(this.constructors.containsKey(method.get$constructorName()))) {
+    if (this.constructors.containsKey(method.get$constructorName())) {
       world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1) && $eq(definition.modifiers.$index(0).kind, 75/*TokenKind.FACTORY*/)) {
-    if ($notnull_bool(this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null)) {
+  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1 && $eq(definition.modifiers.$index(0).kind, 75/*TokenKind.FACTORY*/))) {
+    if (this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null) {
       world.error(('duplicate factory definition of "' + method.get$name() + '"'), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), $assert_String(method.get$name()), (method && method.is$Member()));
     return;
   }
-  if ($notnull_bool(methodName.startsWith('get\$') || methodName.startsWith('set\$'))) {
+  if (methodName.startsWith('get\$') || methodName.startsWith('set\$')) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
     if ($notnull_bool(prop == null)) {
       prop = new PropertyMember($assert_String(propName), this);
       this.members.$setindex(propName, prop);
     }
-    if ($notnull_bool(!(prop instanceof PropertyMember))) {
+    if (!(prop instanceof PropertyMember)) {
       world.error(('property conflicts with field "' + propName + '"'), definition.span);
       return;
     }
-    if ($notnull_bool(methodName[0] == 'g')) {
-      if ($notnull_bool(prop.getter != null)) {
+    if (methodName[0] == 'g') {
+      if (prop.getter != null) {
         world.error(('duplicate getter definition for "' + propName + '"'), definition.span);
       }
       prop.getter = (method && method.is$MethodMember());
     }
     else {
-      if ($notnull_bool(prop.setter != null)) {
+      if (prop.setter != null) {
         world.error(('duplicate setter definition for "' + propName + '"'), definition.span);
       }
       prop.setter = (method && method.is$MethodMember());
     }
     return;
   }
-  if ($notnull_bool(this.members.containsKey(methodName))) {
+  if (this.members.containsKey(methodName)) {
     world.error(('duplicate method definition of "' + method.get$name() + '"'), definition.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition) {
   for (var i = 0;
-   $notnull_bool(i < definition.names.length); i++) {
+   i < definition.names.length; i++) {
     var name = definition.names.$index(i).get$name();
-    if ($notnull_bool(this.members.containsKey(name))) {
+    if (this.members.containsKey(name)) {
       world.error(('duplicate field definition of "' + name + '"'), definition.span);
       return;
     }
     var value = null;
-    if ($notnull_bool(definition.values != null)) {
+    if (definition.values != null) {
       value = definition.values.$index(i);
     }
     var field = new FieldMember($assert_String(name), this, definition, value);
     this.members.$setindex(name, field);
     if ($notnull_bool(this.isNativeType)) {
       field.isNative = true;
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) {
-    if ($notnull_bool(this.factory_ != null)) {
+    if (this.factory_ != null) {
       return this.factory_.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
   var $0;
-  if ($notnull_bool(name == '' && this.definition != null) && this.isClass && this.constructors.get$length() == 0) {
+  if ($notnull_bool(name == '' && this.definition != null && this.isClass) && this.constructors.get$length() == 0) {
     var span = this.definition.span;
     var inits = null, body = null;
     if ($notnull_bool(this.isNativeType)) {
       body = new NativeStatement(null, (span && span.is$SourceSpan()));
       inits = null;
     }
     else {
       body = null;
       inits = [new CallExpression(new SuperExpression((span && span.is$SourceSpan())), [], (span && span.is$SourceSpan()))];
     }
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     var c = new FunctionDefinition(null, null, typeDef.name, [], inits, body, (span && span.is$SourceSpan()));
     this.addMethod(null, (c && c.is$FunctionDefinition()));
     this.constructors.$index('').resolve(this);
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var $0;
   var member = (($0 = this.members.$index(memberName)) && $0.is$Member());
-  if ($notnull_bool(member != null)) {
+  if (member != null) {
     var parentMember = this.getMemberInParents(memberName);
     if ($notnull_bool($ne(parentMember, null))) {
-      if ($notnull_bool(!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library()))) {
+      if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
         member.override(parentMember);
       }
     }
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return libType.get$typeMember();
     }
   }
   return this.getMemberInParents(memberName);
 }
 DefinedType.prototype.getMemberInParents = function(memberName) {
   if ($notnull_bool(this.isClass)) {
-    if ($notnull_bool(this.get$parent() != null)) {
+    if (this.get$parent() != null) {
       return this.get$parent().getMember(memberName);
     }
     else if ($notnull_bool(this.get$isObject())) {
-      if ($notnull_bool(memberName == '\$ne')) {
+      if (memberName == '\$ne') {
         var ret = this._createNotEqualMember();
         this.members.$setindex(memberName, ret);
         return (ret && ret.is$Member());
       }
       return null;
     }
   }
   else {
-    if ($notnull_bool(this.interfaces != null && this.interfaces.length > 0)) {
+    if (this.interfaces != null && this.interfaces.length > 0) {
       var $list = this.interfaces;
       for (var $i = 0;$i < $list.length; $i++) {
         var i = $list.$index($i);
         var ret = i.getMember(memberName);
         if ($notnull_bool($ne(ret, null))) {
           return (ret && ret.is$Member());
         }
       }
       return null;
     }
     else {
       return world.objectType.getMember(memberName);
     }
   }
 }
 DefinedType.prototype.resolveMember = function(memberName) {
   var $0;
   var ret = (($0 = this._resolvedMembers.$index(memberName)) && $0.is$MemberSet());
-  if ($notnull_bool(ret != null)) return ret;
+  if (ret != null) return ret;
   var member = this.getMember(memberName);
-  if ($notnull_bool(member == null)) {
+  if (member == null) {
     return null;
   }
   ret = new MemberSet(member);
   this._resolvedMembers.$setindex(memberName, ret);
   if ($notnull_bool(member.get$isStatic())) {
     return ret;
   }
   else {
     var $list = this.get$subtypes();
     for (var $i = this.get$subtypes().iterator(); $i.hasNext(); ) {
       var t = $i.next();
       var m;
       if ($notnull_bool(!$notnull_bool(this.isClass) && t.get$isClass())) {
         m = t.getMember(memberName);
       }
       else {
         m = t.get$members().$index(memberName);
       }
       if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
     }
     return ret;
   }
 }
 DefinedType.prototype._createNotEqualMember = function() {
   var $0;
   var eq = (($0 = this.members.$index('\$eq')) && $0.is$MethodMember());
-  if ($notnull_bool(eq == null)) {
+  if (eq == null) {
     world.internalError('INTERNAL: object does not define ==', this.definition.span);
   }
   var ne = new MethodMember('\$ne', this, eq.definition);
   ne.isGenerated = true;
   ne.returnType = eq.returnType;
   ne.parameters = eq.parameters;
   ne.isStatic = eq.isStatic;
   ne.isAbstract = eq.isAbstract;
   return ne;
 }
 DefinedType._getDottedName = function(type) {
-  if ($notnull_bool(type.names != null)) {
+  if (type.names != null) {
     var names = map(type.names, (function (n) {
       return n.get$name();
     })
     );
     return type.name.name + '.' + Strings.join((names && names.is$List$String()), '.');
   }
   else {
     return type.name.name;
   }
 }
 DefinedType.prototype.resolveType = function(node, typeErrors) {
   var $0;
-  if ($notnull_bool(node == null)) return world.varType;
-  if ($notnull_bool(node.type != null)) return node.type;
-  if ($notnull_bool((node instanceof NameTypeReference))) {
+  if (node == null) return world.varType;
+  if (node.type != null) return node.type;
+  if ((node instanceof NameTypeReference)) {
     var typeRef = (node && node.is$NameTypeReference());
     var name;
-    if ($notnull_bool(typeRef.names != null)) {
+    if (typeRef.names != null) {
       name = $assert_String(typeRef.names.last().get$name());
     }
     else {
       name = typeRef.name.name;
     }
-    if ($notnull_bool(this.typeParameters != null)) {
+    if (this.typeParameters != null) {
       var $list = this.typeParameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var tp = $list.$index($i);
         if ($notnull_bool($eq(tp.get$name(), name))) {
           typeRef.type = (tp && tp.is$lang_Type());
         }
       }
     }
-    if ($notnull_bool(typeRef.type == null)) {
+    if (typeRef.type == null) {
       typeRef.type = this.library.findType(typeRef);
     }
-    if ($notnull_bool(typeRef.type == null)) {
+    if (typeRef.type == null) {
       var message = ('can not find type ' + DefinedType._getDottedName(typeRef) + '');
       if ($notnull_bool(typeErrors)) {
         world.error($assert_String(message), typeRef.span);
         typeRef.type = world.objectType;
       }
       else {
         world.warning($assert_String(message), typeRef.span);
         typeRef.type = world.varType;
       }
     }
   }
-  else if ($notnull_bool((node instanceof GenericTypeReference))) {
+  else if ((node instanceof GenericTypeReference)) {
     var typeRef = (node && node.is$GenericTypeReference());
     var baseType = this.resolveType(typeRef.baseType, typeErrors);
-    if ($notnull_bool(!$notnull_bool(baseType.get$isGeneric()))) {
+    if (!$notnull_bool(baseType.get$isGeneric())) {
       world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
       return null;
     }
-    if ($notnull_bool(typeRef.typeArguments.length != baseType.get$typeParameters().length)) {
+    if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
       world.error('wrong number of type arguments', typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
-     $notnull_bool(i < typeRef.typeArguments.length); i++) {
+     i < typeRef.typeArguments.length; i++) {
       var extendsType = baseType.get$typeParameters().$index(i).extendsType;
       var typeArg = this.resolveType((($0 = typeRef.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
       typeArgs.add(typeArg);
       if ($notnull_bool($ne(extendsType, null) && !(typeArg instanceof ParameterType))) {
         typeArg.ensureSubtypeOf((extendsType && extendsType.is$lang_Type()), typeRef.typeArguments.$index(i).get$span(), typeErrors);
       }
     }
     typeRef.type = baseType.getOrMakeConcreteType(typeArgs);
   }
-  else if ($notnull_bool((node instanceof FunctionTypeReference))) {
+  else if ((node instanceof FunctionTypeReference)) {
     var typeRef = (node && node.is$FunctionTypeReference());
     var name = '';
-    if ($notnull_bool(typeRef.func.name != null)) name = typeRef.func.name.name;
+    if (typeRef.func.name != null) name = typeRef.func.name.name;
     typeRef.type = this.library.getOrAddFunctionType($assert_String(name), typeRef.func, this);
   }
   else {
     world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1162, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1226, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
-   $notnull_bool(i < typeArgs.length); i++) {
+   i < typeArgs.length; i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1182, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1246, 12);
   var name = _getCallStubName('call', args);
-  if ($notnull_bool(this.varStubs == null)) this.varStubs = $map([]);
+  if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 // ********** Code for FixedCollection **************
 function FixedCollection(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
+FixedCollection.prototype.is$Collection$Type = function(){return this;};
 FixedCollection.prototype.is$Iterable = function(){return this;};
 FixedCollection.prototype.get$value = function() { return this.value; };
 FixedCollection.prototype.iterator = function() {
   return new FixedIterator$E(this.value, this.length);
 }
 FixedCollection.prototype.forEach = function(f) {
   Collections.forEach(this, f);
 }
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new ListFactory$E(), f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == 0;
 }
 // ********** Code for FixedCollection$Type **************
 function FixedCollection$Type(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
 $inherits(FixedCollection$Type, FixedCollection);
+FixedCollection$Type.prototype.is$Collection$Type = function(){return this;};
 FixedCollection$Type.prototype.is$Iterable = function(){return this;};
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
 FixedIterator.prototype.is$Iterator$T = function(){return this;};
 FixedIterator.prototype.get$value = function() { return this.value; };
@@ skipping 15 matching lines @@
 FixedIterator$E.prototype.is$Iterator$T = function(){return this;};
 // ********** Code for Value **************
 function Value(type, code, span, needsTemp) {
   this.isSuper = false
   this.isType = false
   this.type = type;
   this.code = code;
   this.span = span;
   this.needsTemp = needsTemp;
   // Initializers done
-  if ($notnull_bool(this.type == null)) world.internalError('type passed as null', this.span);
+  if (this.type == null) world.internalError('type passed as null', this.span);
 }
 Value.prototype.is$Value = function(){return this;};
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.set$span = function(value) { return this.span = value; };
 Value.prototype.get$_typeIsVarOrParameterType = function() {
   return $notnull_bool(this.type.get$isVar() || (this.type instanceof ParameterType));
 }
 Value.prototype.get$isConst = function() {
   return false;
 }
@@ skipping 13 matching lines @@
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool($ne(member, null))) {
     return member._set(context, node, this, value, isDynamic);
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if ($notnull_bool(this.get$_typeIsVarOrParameterType() && name == '\$ne')) {
-    if ($notnull_bool(args.values.length != 1)) {
+    if (args.values.length != 1) {
       world.warning('wrong number of arguments for !=', node.span);
     }
+    var eq = this.invoke(context, '\$eq', node, args, isDynamic);
     world.gen.corejs.useOperator('\$ne');
-    return new Value(world.varType, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), node.span, true);
+    return new Value(eq.type, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), node.span, true);
   }
-  if ($notnull_bool(name == '\$call')) {
+  if (name == '\$call') {
     if ($notnull_bool(this.isType)) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
     if ($notnull_bool(this.type.needsVarCall(args))) {
       return this._varCall(context, args);
     }
   }
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool(member == null)) {
     return this.invokeNoSuchMethod(context, name, node, args);
@@ skipping 24 matching lines @@
 Value.prototype._tryResolveMember = function(context, name) {
   if ($notnull_bool(this.isSuper)) {
     return this.type.getMember(name);
   }
   else {
     return this.type.resolveMember(name);
   }
 }
 Value.prototype._resolveMember = function(context, name, node, isDynamic) {
   var member;
-  if ($notnull_bool(!$notnull_bool(this.get$_typeIsVarOrParameterType()))) {
+  if (!$notnull_bool(this.get$_typeIsVarOrParameterType())) {
     member = this._tryResolveMember(context, name);
     if ($notnull_bool($ne(member, null) && this.isType) && !$notnull_bool(member.get$isStatic())) {
-      if ($notnull_bool(!$notnull_bool(isDynamic))) {
+      if (!$notnull_bool(isDynamic)) {
         world.error('can not refer to instance member as static', node.span);
       }
       return null;
     }
     if ($notnull_bool(member == null && !$notnull_bool(isDynamic)) && !$notnull_bool(this._hasOverriddenNoSuchMethod())) {
-      var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
+      var typeName = this.type.name == null ? this.type.get$library().name : this.type.name;
       var message = ('can not resolve "' + name + '" on "' + typeName + '"');
       if ($notnull_bool(this.isType)) {
         world.error($assert_String(message), node.span);
       }
       else {
         world.warning($assert_String(message), node.span);
       }
     }
   }
   if ($notnull_bool(member == null && !$notnull_bool(this.isSuper)) && !$notnull_bool(this.isType)) {
@@ skipping 49 matching lines @@
     }
     else if ($notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type)))) {
       return this._wrapDomCallback(toType, arity);
     }
   }
   var fromType = this.type;
   if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
     fromType = world.objectType;
   }
   var bothNum = $notnull_bool(this.type.get$isNum() && toType.get$isNum());
-  if ($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType)) || bothNum) {
+  if ($notnull_bool($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType)) || bothNum)) {
     return this;
   }
-  if ($notnull_bool(!$notnull_bool(toType.isSubtypeOf(this.type)))) {
+  if ($notnull_bool(checked && !$notnull_bool(toType.isSubtypeOf(this.type)))) {
     this.convertWarning(toType, node);
   }
   if ($notnull_bool(options.enableTypeChecks)) {
     return this._typeAssert(context, toType, node);
   }
   else {
     return this;
   }
 }
-Value.prototype.convertToNonNullBool = function(context, node) {
-  if ($notnull_bool(!$notnull_bool(this.type.isAssignable(world.boolType)))) {
-    this.convertWarning(world.boolType, node);
-  }
-  if ($notnull_bool(!$notnull_bool(options.enableTypeChecks))) {
-    return this;
-  }
-  else {
-    if ($notnull_bool(this.code.startsWith('\$notnull_bool'))) {
-      return this;
-    }
-    else {
-      world.gen.corejs.useNotNullBool = true;
-      return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), this.span, true);
-    }
-  }
-}
 Value.prototype._isDomCallback = function(toType) {
-  return ($notnull_bool((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom())));
+  return ((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom()));
 }
 Value.prototype._wrapDomCallback = function(toType, arity) {
   return new Value(toType, ('\$wrap_call\$' + arity + '(' + this.code + ')'), this.span, true);
 }
 Value.prototype._typeAssert = function(context, toType, node) {
-  if ($notnull_bool((toType instanceof ParameterType))) {
+  if ((toType instanceof ParameterType)) {
     var p = (toType && toType.is$ParameterType());
     toType = p.extendsType;
   }
   if ($notnull_bool(toType.get$isObject() || toType.get$isVar())) {
     world.internalError(('We thought ' + this.type.name + ' is not a subtype of ' + toType.name + '?'));
   }
   if ($notnull_bool(toType.get$isNum())) toType = world.numType;
   var check;
   if ($notnull_bool(toType.get$isVoid())) {
     check = ('\$assert_void(' + this.code + ')');
-    if ($notnull_bool(toType.typeCheckCode == null)) {
+    if (toType.typeCheckCode == null) {
       toType.typeCheckCode = "function $assert_void(x) {\n  return x == null ? x : x.is$void(); // throws TypeError\n}";
     }
   }
+  else if ($eq(toType, world.nonNullBool)) {
+    world.gen.corejs.useNotNullBool = true;
+    check = ('\$notnull_bool(' + this.code + ')');
+  }
   else if ($notnull_bool(toType.get$library().get$isCore() && toType.get$typeofName() != null)) {
     check = ('\$assert_' + toType.name + '(' + this.code + ')');
-    if ($notnull_bool(toType.typeCheckCode == null)) {
+    if (toType.typeCheckCode == null) {
       toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  throw new TypeError(\"'\" + x + \"' is not a " + toType.name + ".\");\n}");
     }
   }
   else {
     toType.isTested = true;
     var temp = context.getTemp(this);
     check = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     check = check + (' ' + temp.code + '.is\$' + toType.get$jsname() + '())');
-    if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
+    if ($ne(this, temp)) context.freeTemp((temp && temp.is$Value()));
   }
   return new Value(toType, check, this.span, true);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if ($notnull_bool(toType.get$isVar())) {
     world.error('can not resolve type', span);
-    return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
+    return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, true, 'true', null);
   }
-  if ($notnull_bool((toType instanceof ParameterType))) {
-    return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
+  if ((toType instanceof ParameterType)) {
+    return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, true, 'true', null);
   }
   var testCode = null;
   if ($notnull_bool(toType.get$library().get$isCore())) {
     var typeofName = toType.get$typeofName();
     if ($notnull_bool($ne(typeofName, null))) {
       testCode = ("(typeof(" + this.code + ") " + ($notnull_bool(isTrue) ? '==' : '!=') + " '" + typeofName + "')");
     }
   }
   if ($notnull_bool(toType.get$isClass() && !(toType instanceof ConcreteType))) {
     toType.markUsed();
     testCode = ('(' + this.code + ' instanceof ' + toType.get$jsname() + ')');
-    if ($notnull_bool(!$notnull_bool(isTrue))) {
+    if (!$notnull_bool(isTrue)) {
       testCode = '!' + testCode;
     }
   }
-  if ($notnull_bool(testCode == null)) {
+  if (testCode == null) {
     toType.isTested = true;
     var temp = context.getTemp(this);
     testCode = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     testCode = testCode + (' ' + temp.code + '.is\$' + toType.get$jsname() + ')');
     if ($notnull_bool(isTrue)) {
       testCode = '!!' + testCode;
     }
     else {
       testCode = '!' + testCode;
     }
-    if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
+    if ($ne(this, temp)) context.freeTemp((temp && temp.is$Value()));
   }
-  return new Value(world.boolType, testCode, span, true);
+  return new Value(world.nonNullBool, testCode, span, true);
 }
 Value.prototype.convertWarning = function(toType, node) {
   world.warning(('type "' + this.type.name + '" is not assignable to "' + toType.name + '"'), node.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   var $0;
   var pos = '';
-  if ($notnull_bool(args != null)) {
+  if (args != null) {
     var argsCode = [];
     for (var i = 0;
-     $notnull_bool(i < args.get$length()); i++) {
+     i < args.get$length(); i++) {
       argsCode.add(args.values.$index(i).code);
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), node.span, true), new Value(world.listType, ('[' + pos + ']'), node.span, true)];
   return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 464, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 465, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 449, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 450, 12);
   var argsString = args.getCode();
-  if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
+  if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, true);
   }
   else {
-    if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
+    if (argsString.length > 0) argsString = (', ' + argsString + '');
     world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), this.span, true);
   }
 }
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), false);
 }
 ;
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, span, code) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   Value.call(this, type, code, span, false);
   // Initializers done
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
   return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
 EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 EvaluatedValue.codeWithComments = function(canonicalCode, span) {
-  return $notnull_bool(($notnull_bool(span != null && span.get$text() != canonicalCode))) ? ('' + canonicalCode + '/*' + span.get$text() + '*/') : canonicalCode;
+  return (span != null && span.get$text() != canonicalCode) ? ('' + canonicalCode + '/*' + span.get$text() + '*/') : canonicalCode;
 }
 // ********** Code for ConstListValue **************
 function ConstListValue() {}
 ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
 ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, span) {
   return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
   var values = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
-   $notnull_bool(i < keyValuePairs.length); i += 2) {
+   i < keyValuePairs.length; i += 2) {
     values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
   this.fields = fields;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
@@ skipping 46 matching lines @@
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
 GlobalValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 GlobalValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 GlobalValue.prototype.get$isConst = function() {
   return $notnull_bool(this.exp.get$isConst() && ($notnull_bool(this.field == null || this.field.isFinal)));
 }
 GlobalValue.prototype.get$actualValue = function() {
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
-  if ($notnull_bool($eq(other, this))) {
+  if ($eq(other, this)) {
     return 0;
   }
-  else if ($notnull_bool(this.dependencies.indexOf(other, 0) >= 0)) {
+  else if (this.dependencies.indexOf(other, 0) >= 0) {
     return 1;
   }
-  else if ($notnull_bool(other.dependencies.indexOf(this, 0) >= 0)) {
+  else if (other.dependencies.indexOf(this, 0) >= 0) {
     return -1;
   }
-  else if ($notnull_bool(this.dependencies.length > other.dependencies.length)) {
+  else if (this.dependencies.length > other.dependencies.length) {
     return 1;
   }
-  else if ($notnull_bool(this.dependencies.length < other.dependencies.length)) {
+  else if (this.dependencies.length < other.dependencies.length) {
     return -1;
   }
-  else if ($notnull_bool(this.name == null && other.name != null)) {
+  else if (this.name == null && other.name != null) {
     return 1;
   }
-  else if ($notnull_bool(this.name != null && other.name == null)) {
+  else if (this.name != null && other.name == null) {
     return -1;
   }
-  else if ($notnull_bool(this.name != null)) {
+  else if (this.name != null) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for BareValue **************
 function BareValue(home, outermost, span) {
   this.home = home;
   Value.call(this, outermost.method.declaringType, null, span, false);
   // Initializers done
   this.isType = outermost.get$isStatic();
 }
 $inherits(BareValue, Value);
 BareValue.prototype._tryResolveMember = function(context, name) {
-  $assert($eq(context, this.home), "context == home", "value.dart", 669, 12);
+  $assert($eq(context, this.home), "context == home", "value.dart", 654, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
-    $assert(this.code == null, "code == null", "value.dart", 674, 14);
+    $assert(this.code == null, "code == null", "value.dart", 659, 14);
     if ($notnull_bool(this.isType)) {
       this.code = this.type.get$jsname();
     }
     else {
       this.code = this.home._makeThisCode();
     }
     return member;
   }
   member = this.home.get$library().lookup(name, this.span);
   if ($notnull_bool($ne(member, null))) {
     return member;
   }
   return null;
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
   this._lang_message = _message;
   this._location = _location;
   // Initializers done
 }
 CompilerException.prototype.toString = function() {
-  if ($notnull_bool(this._location != null)) {
+  if (this._location != null) {
     return ('CompilerException: ' + this._location.toMessageString(this._lang_message) + '');
   }
   else {
     return ('CompilerException: ' + this._lang_message + '');
   }
 }
 // ********** Code for World **************
 function World(files) {
   this.errors = 0
   this.warnings = 0
@@ skipping 28 matching lines @@
   this.varType = this.dynamicType;
   this.objectType = (($0 = this._addToCoreLib('Object', true)) && $0.is$DefinedType());
   this.numType = (($0 = this._addToCoreLib('num', false)) && $0.is$DefinedType());
   this.intType = (($0 = this._addToCoreLib('int', false)) && $0.is$DefinedType());
   this.doubleType = (($0 = this._addToCoreLib('double', false)) && $0.is$DefinedType());
   this.boolType = (($0 = this._addToCoreLib('bool', false)) && $0.is$DefinedType());
   this.stringType = (($0 = this._addToCoreLib('String', false)) && $0.is$DefinedType());
   this.listType = (($0 = this._addToCoreLib('List', false)) && $0.is$DefinedType());
   this.mapType = (($0 = this._addToCoreLib('Map', false)) && $0.is$DefinedType());
   this.functionType = (($0 = this._addToCoreLib('Function', false)) && $0.is$DefinedType());
+  this.nonNullBool = new NonNullableType(this.boolType);
 }
 World.prototype._addMember = function(member) {
-  $assert(!$notnull_bool(member.get$isPrivate()), "!member.isPrivate", "world.dart", 141, 12);
+  $assert(!$notnull_bool(member.get$isPrivate()), "!member.isPrivate", "world.dart", 145, 12);
   if ($notnull_bool(member.get$isStatic())) {
     if ($notnull_bool(member.declaringType.get$isTop())) {
       this._addTopName(member);
     }
     return;
   }
   var mset = this._members.$index(member.name);
   if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member);
     this._members.$setindex(mset.get$name(), mset);
@@ skipping 34 matching lines @@
 }
 World.prototype._addJavascriptTopName = function(named) {
   named.set$jsname(('' + named.get$library().get$jsname() + '_' + named.get$name() + ''));
   var existing = this._topNames.$index(named.get$jsname());
   if ($notnull_bool($ne(existing, null) && $ne(existing, named))) {
     world.internalError(('name mangling failed for "' + named.get$jsname() + '" ') + ('("' + named.get$jsname() + '" defined also in ' + existing.get$span().get$locationText() + ')'), named.get$span());
   }
   this._topNames.$setindex(named.get$jsname(), named);
 }
 World.prototype._addType = function(type) {
-  if ($notnull_bool(!$notnull_bool(type.get$isTop()))) this._addTopName(type);
+  if (!$notnull_bool(type.get$isTop())) this._addTopName(type);
 }
 World.prototype._addToCoreLib = function(name, isClass) {
   var ret = new DefinedType(name, this.corelib, null, isClass);
   this.corelib.types.$setindex(name, ret);
   return ret;
 }
 World.prototype.toJsIdentifier = function(name) {
-  if ($notnull_bool(this._jsKeywords == null)) {
+  if (this._jsKeywords == null) {
     this._jsKeywords = HashSetImplementation.HashSetImplementation$from$factory(['break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof', 'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'class', 'enum', 'export', 'extends', 'import', 'super', 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static', 'yield', 'native']);
   }
-  if ($notnull_bool(this._jsKeywords.contains(name))) {
+  if (this._jsKeywords.contains(name)) {
     return name + '_';
   }
   else {
     return name;
   }
 }
 World.prototype.compile = function() {
-  if ($notnull_bool(options.dartScript == null)) {
+  if (options.dartScript == null) {
     this.fatal('no script provided to compile');
     return false;
   }
   try {
     this.info(('compiling ' + options.dartScript + ' with corelib ' + this.corelib + ''));
-    if ($notnull_bool(!$notnull_bool(this.runLeg()))) this.runCompilationPhases();
+    if (!$notnull_bool(this.runLeg())) this.runCompilationPhases();
   } catch (exc) {
     exc = $toDartException(exc);
     if ($notnull_bool(this.get$hasErrors() && !$notnull_bool(options.throwOnErrors))) {
     }
     else {
       throw exc;
     }
   }
   this.printStatus();
   return !$notnull_bool(this.get$hasErrors());
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
-  if ($notnull_bool(!$notnull_bool(options.enableLeg))) return false;
+  if (!$notnull_bool(options.enableLeg)) return false;
   var res = $assert_bool(this.withTiming('try leg compile', (function () {
     return compile($this);
   })
   ));
   if ($notnull_bool(!$notnull_bool(res) && options.legOnly)) {
     this.fatal(("Leg could not compile " + options.dartScript + ""));
     return true;
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
     $this.resolveAll();
   })
   );
   this.withTiming('generate code', (function () {
     var mainMembers = lib.topType.resolveMember('main');
     var main = null;
     if ($notnull_bool(mainMembers == null || mainMembers.get$members().length == 0)) {
       $this.fatal('no main method specified');
     }
-    else if ($notnull_bool(mainMembers.get$members().length > 1)) {
+    else if (mainMembers.get$members().length > 1) {
       var $list = mainMembers.get$members();
       for (var $i = mainMembers.get$members().iterator(); $i.hasNext(); ) {
         var m = $i.next();
         main = m;
         $this.error('more than one main member (using last?)', main.get$span());
       }
     }
     else {
       main = mainMembers.get$members().$index(0);
     }
     var codeWriter = new CodeWriter();
     $this.gen = new WorldGenerator(main, codeWriter);
     $this.gen.run();
     $this.jsBytesWritten = codeWriter.get$text().length;
   })
   );
 }
 World.prototype.getGeneratedCode = function() {
-  if ($notnull_bool(this.legCode != null)) {
-    $assert(options.enableLeg, "options.enableLeg", "world.dart", 306, 14);
+  if (this.legCode != null) {
+    $assert(options.enableLeg, "options.enableLeg", "world.dart", 310, 14);
     return this.legCode;
   }
   else {
     return this.gen.writer.get$text();
   }
 }
 World.prototype.readFile = function(filename) {
   try {
     var sourceFile = this.reader.readFile(filename);
     this.dartBytesRead += sourceFile.get$text().length;
     return sourceFile;
   } catch (e) {
     e = $toDartException(e);
     this.warning(('Error reading file: ' + filename + ''));
     return new SourceFile(filename, '');
   }
 }
 World.prototype.getOrAddLibrary = function(filename) {
   var $0;
   var library = (($0 = this.libraries.$index(filename)) && $0.is$Library());
-  if ($notnull_bool(library == null)) {
+  if (library == null) {
     library = new Library(this.readFile(filename));
     this.info(('read library ' + filename + ''));
-    if ($notnull_bool(!$notnull_bool(library.get$isCore()) && !$notnull_bool(library.imports.some((function (li) {
+    if (!$notnull_bool(library.get$isCore()) && !library.imports.some((function (li) {
       return li.get$library().get$isCore();
     })
-    )))) {
+    )) {
       library.imports.add(new LibraryImport(this.corelib));
     }
     this.libraries.$setindex(filename, library);
     this._todo.add(library);
   }
   return library;
 }
 World.prototype.process = function() {
-  while ($notnull_bool(this._todo.length > 0)) {
+  while (this._todo.length > 0) {
     var todo = this._todo;
     this._todo = [];
     for (var $i = 0;$i < todo.length; $i++) {
       var lib = todo.$index($i);
       lib.visitSources();
     }
   }
 }
 World.prototype.processScript = function(filename) {
   var library = this.getOrAddLibrary(filename);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
   var $list = this.libraries.getValues();
   for (var $i = this.libraries.getValues().iterator(); $i.hasNext(); ) {
     var lib = $i.next();
     lib.resolve();
   }
 }
 World.prototype._message = function(message, span, span1, span2, throwing) {
   var text = message;
-  if ($notnull_bool(span != null)) {
+  if (span != null) {
     text = span.toMessageString(message);
   }
   print(text);
-  if ($notnull_bool(span1 != null)) {
+  if (span1 != null) {
     print(span1.toMessageString(message));
   }
-  if ($notnull_bool(span2 != null)) {
+  if (span2 != null) {
     print(span2.toMessageString(message));
   }
   if ($notnull_bool(throwing)) {
     $throw(new CompilerException(message, span));
   }
 }
 World.prototype.error = function(message, span, span1, span2) {
   this.errors++;
   this._message(('error: ' + message + ''), span, span1, span2, options.throwOnErrors);
 }
@@ skipping 18 matching lines @@
 }
 World.prototype.get$hasErrors = function() {
   return this.errors > 0;
 }
 World.prototype.printStatus = function() {
   this.info(('compiled ' + this.dartBytesRead + ' bytes Dart -> ' + this.jsBytesWritten + ' bytes JS'));
   if ($notnull_bool(this.get$hasErrors())) {
     print(('compilation failed with ' + this.errors + ' errors'));
   }
   else {
-    if ($notnull_bool(this.warnings > 0)) {
+    if (this.warnings > 0) {
       this.info(('compilation completed successfully with ' + this.warnings + ' warnings'));
     }
     else {
       this.info('compilation completed sucessfully');
     }
   }
 }
 World.prototype.withTiming = function(name, f) {
   var sw = new StopWatchImplementation();
   sw.start();
@@ skipping 18 matching lines @@
   this.throwOnFatal = false
   this.showInfo = false
   this.showWarnings = true
   // Initializers done
   this.libDir = homedir + '/lib';
   var ignoreUnrecognizedFlags = false;
   var passedLibDir = false;
   this.childArgs = [];
   loop:
   for (var i = 2;
-   $notnull_bool(i < args.length); i++) {
+   i < args.length; i++) {
     var arg = args.$index(i);
     switch (arg) {
       case '--enable_leg':
 
         this.enableLeg = true;
         continue loop;
 
       case '--leg_only':
 
         this.enableLeg = true;
@@ skipping 51 matching lines @@
         this.throwOnWarnings = true;
         continue loop;
 
       case '--compile-only':
 
         this.compileOnly = true;
         continue loop;
 
       default:
 
-        if ($notnull_bool(arg.endsWith('.dart'))) {
+        if (arg.endsWith('.dart')) {
           this.dartScript = $assert_String(arg);
           this.childArgs = (($0 = args.getRange(i + 1, args.length - i - 1)) && $0.is$List$String());
           break loop;
         }
-        else if ($notnull_bool(arg.startsWith('--out='))) {
+        else if (arg.startsWith('--out=')) {
           this.outfile = arg.substring('--out='.length);
         }
-        else if ($notnull_bool(arg.startsWith('--libdir='))) {
+        else if (arg.startsWith('--libdir=')) {
           this.libDir = arg.substring('--libdir='.length);
           passedLibDir = true;
         }
         else {
-          if ($notnull_bool(!$notnull_bool(ignoreUnrecognizedFlags))) {
+          if (!$notnull_bool(ignoreUnrecognizedFlags)) {
             print(('unrecognized flag: "' + arg + '"'));
           }
         }
 
     }
   }
-  if ($notnull_bool(!$notnull_bool(passedLibDir) && !$notnull_bool(files.fileExists(this.libDir)))) {
+  if (!$notnull_bool(passedLibDir) && !$notnull_bool(files.fileExists(this.libDir))) {
     var temp = 'frog/lib';
     if ($notnull_bool(files.fileExists(temp))) {
       this.libDir = $assert_String(temp);
     }
     else {
       this.libDir = 'lib';
     }
   }
 }
 // ********** Code for LibraryReader **************
@@ skipping 73 matching lines @@
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$returnType = function() {
   var $0;
-  return (($0 = $notnull_bool(this.member != null) ? this.member.get$returnType() : world.varType) && $0.is$lang_Type());
+  return (($0 = this.member != null ? this.member.get$returnType() : world.varType) && $0.is$lang_Type());
 }
 VarMethodStub.prototype.get$typeName = function() {
-  return $notnull_bool(this.member != null) ? this.member.declaringType.get$jsname() : 'Object';
+  return this.member != null ? this.member.declaringType.get$jsname() : 'Object';
 }
 VarMethodStub.prototype.generate = function(code) {
   code.write(('' + this.get$typeName() + '.prototype.' + this.name + ' = '));
   this.generateBody(code);
   code.writeln(';');
 }
 VarMethodStub.prototype.generateBody = function(code) {
   if ($notnull_bool(this._useDirectCall(this.member, this.args))) {
     code.write(('' + this.get$typeName() + '.prototype.' + this.member.get$jsname() + ''));
   }
   else {
     code.enterBlock(('function(' + this.args.getCode() + ') {'));
     code.writeln(('return ' + this.body.code + ';'));
     code.exitBlock('}');
   }
 }
 VarMethodStub.prototype._useDirectCall = function(member, args) {
-  if ($notnull_bool((member instanceof MethodMember) && $ne(member.declaringType.get$library(), world.get$dom()))) {
+  if ((member instanceof MethodMember) && $ne(member.declaringType.get$library(), world.get$dom())) {
     var method = (member && member.is$MethodMember());
     if ($notnull_bool(method.needsArgumentConversion(args))) {
       return false;
     }
     for (var i = args.get$length();
-     $notnull_bool(i < method.parameters.length); i++) {
-      if ($notnull_bool(method.parameters.$index(i).get$value().code != 'null')) {
+     i < method.parameters.length; i++) {
+      if (method.parameters.$index(i).get$value().code != 'null') {
         return false;
       }
     }
     return method.namesInOrder(args);
   }
   else {
     return false;
   }
 }
 // ********** Code for VarMethodSet **************
 function VarMethodSet(name, members, callArgs, returnType) {
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$members = function() { return this.members; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
   return $assert_String(this.members.$index(0).get$name());
 }
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
-  if ($notnull_bool(this._fallbackStubs != null)) return;
+  if (this._fallbackStubs != null) return;
   this._fallbackStubs = [];
   var $list = this.members;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
     var target = new Value(member.declaringType, 'this', node.span, true);
     var result = member.invoke$4(context, node, target, this.args);
     var stub = new VarMethodStub(this.name, member, this.args, result);
     var type = member.declaringType;
-    if ($notnull_bool($ne(type.get$library(), world.get$dom()) && !$notnull_bool(type.get$isObject()))) {
+    if ($ne(type.get$library(), world.get$dom()) && !$notnull_bool(type.get$isObject())) {
       VarMethodSet._addVarStub((type && type.is$lang_Type()), (stub && stub.is$VarMember()));
     }
     else {
       this._fallbackStubs.add(stub);
     }
   }
   var target = new Value(world.objectType, 'this', node.span, true);
   var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
   var stub = new VarMethodStub(this.name, null, this.args, result);
-  if ($notnull_bool(this._fallbackStubs.length == 0)) {
+  if (this._fallbackStubs.length == 0) {
     VarMethodSet._addVarStub(world.objectType, (stub && stub.is$VarMember()));
   }
   else {
     this._fallbackStubs.add(stub);
     world.gen.corejs.useVarMethod = true;
   }
 }
 VarMethodSet._addVarStub = function(type, stub) {
-  if ($notnull_bool(type.varStubs == null)) type.varStubs = $map([]);
+  if (type.varStubs == null) type.varStubs = $map([]);
   type.varStubs.$setindex(stub.name, stub);
 }
 VarMethodSet.prototype.generate = function(code) {
-  if ($notnull_bool(this._fallbackStubs.length == 0)) return;
+  if (this._fallbackStubs.length == 0) return;
   code.enterBlock(('\$varMethod("' + this.name + '", {'));
   var lastOne = this._fallbackStubs.$index(this._fallbackStubs.length - 1);
   var $list = this._fallbackStubs;
   for (var $i = 0;$i < $list.length; $i++) {
     var stub = $list.$index($i);
     code.write(('"' + stub.get$typeName() + '": '));
     stub.generateBody(code);
     code.writeln($notnull_bool($eq(stub, lastOne)) ? '' : ',');
   }
   code.exitBlock('});');
 }
 VarMethodSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 }
 ;
 // ********** Code for top level **************
 function map(source, mapper) {
   var result = new ListFactory();
-  if ($notnull_bool(!!(source && source.is$List))) {
+  if (!!(source && source.is$List)) {
     var list = (source && source.is$List());
     result.length = list.length;
     for (var i = 0;
-     $notnull_bool(i < list.length); i++) {
+     i < list.length; i++) {
       result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
     for (var $i = source.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       result.add(mapper(item));
     }
   }
   return result;
@@ skipping 17 matching lines @@
   })
   );
   var values = [];
   for (var $i = 0;$i < keys.length; $i++) {
     var k = keys.$index($i);
     values.add(map.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
-  return $notnull_bool(text.startsWith('"""') || text.startsWith("'''"));
+  return text.startsWith('"""') || text.startsWith("'''");
 }
 function isRawMultilineString(text) {
-  return $notnull_bool(text.startsWith('@"""') || text.startsWith("@'''"));
+  return text.startsWith('@"""') || text.startsWith("@'''");
 }
 function parseStringLiteral(lit) {
-  if ($notnull_bool(lit.startsWith('@'))) {
+  if (lit.startsWith('@')) {
     if ($notnull_bool(isRawMultilineString(lit))) {
       return stripLeadingNewline(lit.substring(4, lit.length - 3));
     }
     else {
       return lit.substring(2, lit.length - 1);
     }
   }
   else if ($notnull_bool(isMultilineString(lit))) {
     lit = lit.substring(3, lit.length - 3).replaceAll('\\\$', '\$');
     return stripLeadingNewline(lit);
   }
   else {
     return lit.substring(1, lit.length - 1).replaceAll('\\\$', '\$');
   }
 }
 function stripLeadingNewline(text) {
-  if ($notnull_bool(text.startsWith('\n'))) {
+  if (text.startsWith('\n')) {
     return text.substring(1);
   }
-  else if ($notnull_bool(text.startsWith('\r'))) {
-    if ($notnull_bool(text.startsWith('\r\n'))) {
+  else if (text.startsWith('\r')) {
+    if (text.startsWith('\r\n')) {
       return text.substring(2);
     }
     else {
       return text.substring(1);
     }
   }
   else {
     return text;
   }
 }
 var world;
 function initializeWorld(files) {
   $assert(world == null, "world == null", "world.dart", 13, 10);
   world = new World(files);
   world.init();
 }
 function lang_compile(homedir, args, files) {
   parseOptions(homedir, args, files);
   initializeWorld(files);
   var success = world.compile();
-  if ($notnull_bool(options.outfile != null)) {
+  if (options.outfile != null) {
     if ($notnull_bool(success)) {
       var code = world.getGeneratedCode();
-      if ($notnull_bool(!$notnull_bool(options.outfile.endsWith('.js')))) {
+      if (!options.outfile.endsWith('.js')) {
         code = '#!/usr/bin/env node\n' + code;
       }
       world.files.writeString(options.outfile, code);
     }
     else {
       world.files.writeString(options.outfile, "throw 'Sorry, but I could not generate reasonable code to run.\\n';");
     }
   }
   return $assert_bool(success);
 }
 var options;
 function parseOptions(homedir, args, files) {
   $assert(options == null, "options == null", "frog_options.dart", 10, 10);
   options = new FrogOptions(homedir, args, files);
 }
 function _getCallStubName(name, args) {
   var nameBuilder = new StringBufferImpl(('' + name + '\$' + args.get$bareCount() + ''));
   for (var i = args.get$bareCount();
-   $notnull_bool(i < args.get$length()); i++) {
+   i < args.get$length(); i++) {
     nameBuilder.add('\$').add(args.getName(i));
   }
   return nameBuilder.toString();
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = get$path().dirname(get$fs().realpathSync($assert_String(process.argv.$index(1))));
   var argv = ListFactory.ListFactory$from$factory(process.argv);
   if ($notnull_bool(lang_compile($assert_String(homedir), (argv && argv.is$List$String()), new NodeFileSystem()))) {
     var code = world.getGeneratedCode();
-    if ($notnull_bool(!$notnull_bool(options.compileOnly))) {
+    if (!$notnull_bool(options.compileOnly)) {
       process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll(options.childArgs);
       get$vm().runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
 }
 //  ********** Globals **************
@@ skipping 124 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);