Better runtime type checks.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 159 matching lines @@
     ret.$setindex(items[i++], items[i++]);
   }
   return ret;
 }
 
 function $assert(test, text, url, line, column) {
   if (typeof test == 'function') test = test();
   if (!test) $throw(new AssertError(text, url, line, column));
 }
 
+function $notnull_bool(test) {
+  if (test == null || typeof(test) != 'boolean') {
+    $throw(new TypeError('must be "true" or "false"'));
+  }
+  return test === true;
+}
+
 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
     Error.captureStackTrace(e, $throw);
   }
   throw e;
 }
 
@@ skipping 143 matching lines @@
   Object.defineProperty(proto, name, {value: method || methods['Object']});
 }
 // ********** Code for Clock **************
 function Clock() {}
 Clock.now = function() {
   return new Date().getTime();
 }
 Clock.frequency = function() {
   return 1000;
 }
+// ********** Code for AssertError **************
+function AssertError(failedAssertion, url, line, column) {
+  this.failedAssertion = failedAssertion;
+  this.url = url;
+  this.line = line;
+  this.column = column;
+  // Initializers done
+}
+AssertError.prototype.toString = function() {
+  return ("Failed assertion: '" + this.failedAssertion + "' is not true ") + ("in " + this.url + " at line " + this.line + ", column " + this.column + ".");
+}
 // ********** Code for Object **************
 Object.prototype.get$dynamic = function() {
   return this;
 }
 Object.prototype.noSuchMethod = function(name, args) {
   $throw(new NoSuchMethodException(this, name, args));
 }
 Object.prototype.forEach$1 = function($0) {
   return this.noSuchMethod("forEach", [$0]);
 }
@@ skipping 11 matching lines @@
 }
 ;
 Object.prototype.set_$4 = function($0, $1, $2, $3) {
   return this.noSuchMethod("set_", [$0, $1, $2, $3]);
 }
 ;
 Object.prototype.visitPostfixExpression$1 = function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
 }
 ;
+function $assert_bool(x) {
+  if (x == null || typeof(x) == "boolean") return x;
+  throw new TypeError("'" + x + "' is not a bool.");
+}
 // ********** Code for IllegalAccessException **************
 function IllegalAccessException() {
   // Initializers done
 }
 IllegalAccessException.prototype.toString = function() {
   return "Attempt to modify an immutable object";
 }
 // ********** 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;
-   i < this._arguments.length; i++) {
-    if (i > 0) {
+   $notnull_bool(i < this._arguments.length); i++) {
+    if ($notnull_bool(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 41 matching lines @@
 }
 Math.min = function(a, b) {
   if (a == b) return a;
     if (a < b) {
       if (isNaN(b)) return b;
       else return a;
     }
     if (isNaN(a)) return a;
     else return b;
 }
+function $assert_num(x) {
+  if (x == null || typeof(x) == "number") return x;
+  throw new TypeError("'" + x + "' is not a num.");
+}
+function $assert_String(x) {
+  if (x == null || typeof(x) == "string") return x;
+  throw new TypeError("'" + x + "' is not a String.");
+}
 // ********** Code for Strings **************
 function Strings() {}
 Strings.String$fromCharCodes$factory = function(charCodes) {
   return StringBase.createFromCharCodes(charCodes);
 }
 Strings.join = function(strings, separator) {
   return StringBase.join(strings, separator);
 }
 // ********** Code for top level **************
 function print(obj) {
   if (typeof console == 'object') {
     if (obj) obj = obj.toString();
     console.log(obj);
   } else {
     write(obj);
     write('\n');
   }
 }
 //  ********** Library dart:coreimpl **************
 // ********** Code for ListFactory **************
 ListFactory = Array;
 ListFactory.prototype.is$List = function(){return this;};
+ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
+ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
+ListFactory.prototype.is$List$String = function(){return this;};
+ListFactory.prototype.is$List$T = function(){return this;};
+ListFactory.prototype.is$List$Value = function(){return this;};
+ListFactory.prototype.is$List$int = function(){return this;};
+ListFactory.prototype.is$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
+  var $0;
   var list = [];
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.add(e);
   }
   return list;
 }
 ListFactory.prototype.add = function(value) {
   this.push(value);
 }
 ListFactory.prototype.addLast = function(value) {
   this.push(value);
 }
 ListFactory.prototype.addAll = function(collection) {
+  var $0;
   for (var $i = collection.iterator(); $i.hasNext(); ) {
     var item = $i.next();
     this.add(item);
   }
 }
 ListFactory.prototype.clear = function() {
   this.length = 0;
 }
 ListFactory.prototype.removeLast = function() {
   return this.pop();
@@ skipping 26 matching lines @@
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
-  if (!this.hasNext()) {
-    $throw(const$4/*const NoMoreElementsException()*/);
+  if ($notnull_bool(!this.hasNext())) {
+    $throw(const$0/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
 function ImmutableList(length0) {
   this._length = length0;
   ListFactory$E.call(this, length0);
   // Initializers done
 }
 $inherits(ImmutableList, ListFactory$E);
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.length);
   for (var i = 0;
-   i < other.length; i++) {
+   $notnull_bool(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(length0) {
   $throw(const$221/*const IllegalAccessException()*/);
 }
@@ skipping 23 matching lines @@
   $throw(const$221/*const IllegalAccessException()*/);
 }
 ImmutableList.prototype.removeLast = function() {
   $throw(const$221/*const IllegalAccessException()*/);
 }
 // ********** Code for ImmutableMap **************
 function ImmutableMap(keyValuePairs) {
   this._internal = $map([]);
   // Initializers done
   for (var i = 0;
-   i < keyValuePairs.length; i += 2) {
+   $notnull_bool(i < keyValuePairs.length); i += 2) {
     this._internal.$setindex(keyValuePairs.$index(i), keyValuePairs.$index(i + 1));
   }
 }
+ImmutableMap.prototype.is$Map = function(){return this;};
 ImmutableMap.prototype.$index = function(key) {
   return this._internal.$index(key);
 }
 ImmutableMap.prototype.isEmpty = function() {
   return this._internal.isEmpty();
 }
 ImmutableMap.prototype.get$length = function() {
   return this._internal.get$length();
 }
 Object.defineProperty(ImmutableMap.prototype, "length", {
@@ skipping 42 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 (thisValue < other) {
+  if ($notnull_bool(thisValue < other)) {
     return -1;
   }
-  else if (thisValue > other) {
+  else if ($notnull_bool(thisValue > other)) {
     return 1;
   }
-  else if (thisValue == other) {
-    if (thisValue == 0) {
+  else if ($notnull_bool(thisValue == other)) {
+    if ($notnull_bool(thisValue == 0)) {
       var thisIsNegative = this.isNegative();
       var otherIsNegative = other.isNegative();
-      if ($eq(thisIsNegative, otherIsNegative)) return 0;
-      if (thisIsNegative) return -1;
+      if ($notnull_bool($eq(thisIsNegative, otherIsNegative))) return 0;
+      if ($notnull_bool(thisIsNegative)) return -1;
       return 1;
     }
     return 0;
   }
-  else if (this.isNaN()) {
-    if (other.isNaN()) {
+  else if ($notnull_bool(this.isNaN())) {
+    if ($notnull_bool(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 (this._msg == null) ? "Exception" : ("Exception: " + this._msg + "");
+  return $notnull_bool((this._msg == null)) ? "Exception" : ("Exception: " + this._msg + "");
 }
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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$Map = function(){return this;};
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation._firstProbe = function(hashCode, length0) {
   return hashCode & (length0 - 1);
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length0) {
   return (currentProbe + numberOfProbes) & (length0 - 1);
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
-  var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
+  var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
-  while (true) {
+  while ($notnull_bool(true)) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) {
-      if (insertionIndex < 0) return hash;
+    if ($notnull_bool(existingKey == null)) {
+      if ($notnull_bool(insertionIndex < 0)) return hash;
       return insertionIndex;
     }
-    else if ($eq(existingKey, key)) {
+    else if ($notnull_bool($eq(existingKey, key))) {
       return hash;
     }
-    else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
+    else if ($notnull_bool((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey))) {
       insertionIndex = hash;
     }
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._probeForLookup = function(key) {
-  var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
+  var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  while (true) {
+  while ($notnull_bool(true)) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
-    if ($eq(existingKey, key)) return hash;
+    if ($notnull_bool(existingKey == null)) return -1;
+    if ($notnull_bool($eq(existingKey, key))) return hash;
     hash = HashMapImplementation._nextProbe(hash, numberOfProbes++, this._keys.length);
   }
 }
 HashMapImplementation.prototype._ensureCapacity = function() {
   var newNumberOfEntries = this._numberOfEntries + 1;
-  if (newNumberOfEntries >= this._loadLimit) {
+  if ($notnull_bool(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 (this._numberOfDeleted > numberOfFree) {
+  if ($notnull_bool(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)", "/Volumes/Data/dart/dart/corelib/src/implementation/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;
-   i < capacity; i++) {
+   $notnull_bool(i < capacity); i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key === HashMapImplementation._deletedKey) {
+    if ($notnull_bool(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.clear = function() {
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   var length0 = this._keys.length;
   for (var i = 0;
-   i < length0; i++) {
+   $notnull_bool(i < length0); i++) {
     this._keys.$setindex(i);
     this._values.$setindex(i);
   }
 }
 HashMapImplementation.prototype.$setindex = function(key, value) {
   this._ensureCapacity();
   var index = this._probeForAdding(key);
-  if ((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey)) {
+  if ($notnull_bool((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 (index < 0) return null;
+  if ($notnull_bool(index < 0)) return null;
   return this._values.$index(index);
 }
 HashMapImplementation.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
-  if (index >= 0) {
+  if ($notnull_bool(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 length0 = this._keys.length;
   for (var i = 0;
-   i < length0; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
+   $notnull_bool(i < length0); i++) {
+    if ($notnull_bool((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);
 }
 HashMapImplementation.prototype.forEach$1 = HashMapImplementation.prototype.forEach;
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length0) {
   return hashCode & (length0 - 1);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length0) {
   return (currentProbe + numberOfProbes) & (length0 - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
-  var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
+  var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
-  while (true) {
+  while ($notnull_bool(true)) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) {
-      if (insertionIndex < 0) return hash;
+    if ($notnull_bool(existingKey == null)) {
+      if ($notnull_bool(insertionIndex < 0)) return hash;
       return insertionIndex;
     }
-    else if ($eq(existingKey, key)) {
+    else if ($notnull_bool($eq(existingKey, key))) {
       return hash;
     }
-    else if ((insertionIndex < 0) && (HashMapImplementation._deletedKey === existingKey)) {
+    else if ($notnull_bool((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(key.hashCode(), this._keys.length);
+  var hash = HashMapImplementation._firstProbe($assert_num(key.hashCode()), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
-  while (true) {
+  while ($notnull_bool(true)) {
     var existingKey = this._keys.$index(hash);
-    if (existingKey == null) return -1;
-    if ($eq(existingKey, key)) return hash;
+    if ($notnull_bool(existingKey == null)) return -1;
+    if ($notnull_bool($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 (newNumberOfEntries >= this._loadLimit) {
+  if ($notnull_bool(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 (this._numberOfDeleted > numberOfFree) {
+  if ($notnull_bool(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)", "/Volumes/Data/dart/dart/corelib/src/implementation/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;
-   i < capacity; i++) {
+   $notnull_bool(i < capacity); i++) {
     var key = oldKeys.$index(i);
-    if (key == null || key === HashMapImplementation._deletedKey) {
+    if ($notnull_bool(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 ((this._keys.$index(index) == null) || (this._keys.$index(index) === HashMapImplementation._deletedKey)) {
+  if ($notnull_bool((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 (index >= 0) {
+  if ($notnull_bool(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 length0 = this._keys.length;
   for (var i = 0;
-   i < length0; i++) {
-    if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
+   $notnull_bool(i < length0); i++) {
+    if ($notnull_bool((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$HInstruction$HInstruction **************
 function HashMapImplementation$HInstruction$HInstruction() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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$HInstruction$HInstruction, HashMapImplementation);
+HashMapImplementation$HInstruction$HInstruction.prototype.is$Map = function(){return this;};
 HashMapImplementation$HInstruction$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 (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Node$Element **************
 function HashMapImplementation$Node$Element() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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$Element(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Node$Element, HashMapImplementation);
+HashMapImplementation$Node$Element.prototype.is$Map = function(){return this;};
 HashMapImplementation$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 (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 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 (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$String$EvaluatedValue._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$String **************
 function HashMapImplementation$String$String() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 HashMapImplementation$String$String._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Type$Type **************
 function HashMapImplementation$Type$Type() {
   // Initializers done
-  if (HashMapImplementation._deletedKey == null) {
+  if ($notnull_bool(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 = function(){return this;};
 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$Iterable = function(){return this;};
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
+  var $0;
   var set = new HashSetImplementation();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     set.add(e);
   }
   return set;
 }
 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 (!this._backingMap.containsKey(value)) return false;
+  if ($notnull_bool(!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 (f(key)) result.add(key);
+    if ($notnull_bool(f(key))) result.add(key);
   }
   );
   return result;
 }
 HashSetImplementation.prototype.some = function(f) {
   var keys = this._backingMap.getKeys();
   return 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);
 }
 HashSetImplementation.prototype.forEach$1 = HashSetImplementation.prototype.forEach;
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
+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$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$Iterable = function(){return this;};
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
-  if (this._nextValidIndex >= this._entries.length) return false;
-  if (this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey) {
+  if ($notnull_bool(this._nextValidIndex >= this._entries.length)) return false;
+  if ($notnull_bool(this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey)) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
-  if (!this.hasNext()) {
-    $throw(const$4/*const NoMoreElementsException()*/);
+  if ($notnull_bool(!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 (++this._nextValidIndex >= length) break;
+    if ($notnull_bool(++this._nextValidIndex >= length)) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ((entry == null) || (entry === deletedKey))
+  while ($notnull_bool((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._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
-    if (++this._nextValidIndex >= length) break;
+    if ($notnull_bool(++this._nextValidIndex >= length)) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
-  while ((entry == null) || (entry === deletedKey))
+  while ($notnull_bool((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 **************
 function KeyValuePair$K$V(key, value) {
   this.key = key;
   this.value = value;
   // Initializers done
 }
 $inherits(KeyValuePair$K$V, KeyValuePair);
 // ********** Code for KeyValuePair$String$Keyword **************
 function KeyValuePair$String$Keyword() {}
 $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 = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
-  if (this._map.containsKey(key)) {
+  if ($notnull_bool(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 entry = this._map.$index(key);
-  if (entry == null) return null;
+  if ($notnull_bool(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", "/Volumes/Data/dart/dart/corelib/src/implementation/linked_hash_map.dart", 75, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
   var list = new ListFactory$V(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
+  $assert(index == this.get$length(), "index == length", "/Volumes/Data/dart/dart/corelib/src/implementation/linked_hash_map.dart", 86, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
   this._list.forEach(function _(entry) {
     f(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
@@ skipping 12 matching lines @@
   this._list.clear();
 }
 LinkedHashMapImplementation.prototype.forEach$1 = LinkedHashMapImplementation.prototype.forEach;
 // ********** Code for LinkedHashMapImplementation$String$Keyword **************
 function LinkedHashMapImplementation$String$Keyword() {
   // Initializers done
   this._map = new HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword();
   this._list = new DoubleLinkedQueue$KeyValuePair$String$Keyword();
 }
 $inherits(LinkedHashMapImplementation$String$Keyword, LinkedHashMapImplementation);
+LinkedHashMapImplementation$String$Keyword.prototype.is$Map = function(){return this;};
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   // Initializers done
   this._element = e;
 }
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
@@ skipping 122 matching lines @@
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 // ********** Code for DoubleLinkedQueue **************
 function DoubleLinkedQueue() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
+DoubleLinkedQueue.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue.DoubleLinkedQueue$from$factory = function(other) {
+  var $0;
   var list = new DoubleLinkedQueue();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.addLast(e);
   }
   return list;
 }
 DoubleLinkedQueue.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue.prototype.add = function(value) {
   this.addLast(value);
 }
 DoubleLinkedQueue.prototype.addAll = function(collection) {
+  var $0;
   for (var $i = collection.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     this.add(e);
   }
 }
 DoubleLinkedQueue.prototype.removeLast = function() {
   return this._sentinel._previous.remove();
 }
 DoubleLinkedQueue.prototype.last = function() {
   return this._sentinel._previous.get$element();
@@ skipping 14 matching lines @@
 });
 DoubleLinkedQueue.prototype.isEmpty = function() {
   return (this._sentinel._next === this._sentinel);
 }
 DoubleLinkedQueue.prototype.clear = function() {
   this._sentinel._next = this._sentinel;
   this._sentinel._previous = this._sentinel;
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while ($notnull_bool(entry !== this._sentinel)) {
     f(entry._element);
     entry = entry._next;
   }
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
-    if (f(entry._element)) return true;
+  while ($notnull_bool(entry !== this._sentinel)) {
+    if ($notnull_bool(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 (entry !== this._sentinel) {
-    if (f(entry._element)) other.addLast(entry._element);
+  while ($notnull_bool(entry !== this._sentinel)) {
+    if ($notnull_bool(f(entry._element))) other.addLast(entry._element);
     entry = entry._next;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator$E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach$1 = DoubleLinkedQueue.prototype.forEach;
 // ********** Code for DoubleLinkedQueue$E **************
 function DoubleLinkedQueue$E() {
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$E();
 }
 $inherits(DoubleLinkedQueue$E, DoubleLinkedQueue);
+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$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.clear = function() {
   this._sentinel._next = this._sentinel;
   this._sentinel._previous = this._sentinel;
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
-  while (entry !== this._sentinel) {
+  while ($notnull_bool(entry !== this._sentinel)) {
     f(entry._element);
     entry = entry._next;
   }
 }
 // ********** 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$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$SourceString **************
 function DoubleLinkedQueue$SourceString() {}
 $inherits(DoubleLinkedQueue$SourceString, DoubleLinkedQueue);
+DoubleLinkedQueue$SourceString.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue$SourceString.DoubleLinkedQueue$from$factory = function(other) {
+  var $0;
   var list = new DoubleLinkedQueue();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.addLast(e);
   }
   return list;
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
-  if (!this.hasNext()) {
-    $throw(const$4/*const NoMoreElementsException()*/);
+  if ($notnull_bool(!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);
 // ********** Code for StopWatchImplementation **************
 function StopWatchImplementation() {
   this._start = null;
   this._stop = null;
   // Initializers done
 }
 StopWatchImplementation.prototype.start = function() {
-  if (this._start == null) {
+  if ($notnull_bool(this._start == null)) {
     this._start = Clock.now();
   }
   else {
-    if (this._stop == null) {
+    if ($notnull_bool(this._stop == null)) {
       return;
     }
     this._start = Clock.now() - (this._stop - this._start);
   }
 }
 StopWatchImplementation.prototype.stop = function() {
-  if (this._start == null) {
+  if ($notnull_bool(this._start == null)) {
     return;
   }
   this._stop = Clock.now();
 }
 StopWatchImplementation.prototype.elapsed = function() {
-  if (this._start == null) {
+  if ($notnull_bool(this._start == null)) {
     return 0;
   }
-  return (this._stop == null) ? (Clock.now() - this._start) : (this._stop - this._start);
+  return $notnull_bool((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.is$StringBuffer = function(){return this;};
 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 (str == null || str.isEmpty()) return this;
+  if ($notnull_bool(str == null || str.isEmpty())) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
+  var $0;
   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 (this._buffer.length == 0) return "";
-  if (this._buffer.length == 1) return this._buffer.$index(0);
+  if ($notnull_bool(this._buffer.length == 0)) return "";
+  if ($notnull_bool(this._buffer.length == 1)) return 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 (strings.length == 0) return '';
+  if ($notnull_bool(strings.length == 0)) return '';
   var s = strings.$index(0);
   for (var i = 1;
-   i < strings.length; i++) {
+   $notnull_bool(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 32 matching lines @@
       this.hash_ = this.hash_ & ((1 << 29) - 1);
     }
     return this.hash_;
 }
 StringImplementation.prototype.compareTo = function(other) {
   return this == other ? 0 : this < other ? -1 : 1;
 }
 // ********** Code for Collections **************
 function Collections() {}
 Collections.forEach = function(iterable, f) {
+  var $0;
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     f(e);
   }
 }
 Collections.some = function(iterable, f) {
+  var $0;
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
-    if (f(e)) return true;
+    if ($notnull_bool(f(e))) return true;
   }
   return false;
 }
 Collections.filter = function(source, destination, f) {
+  var $0;
   for (var $i = source.iterator(); $i.hasNext(); ) {
     var e = $i.next();
-    if (f(e)) destination.add(e);
+    if ($notnull_bool(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 (!((other instanceof DateImplementation))) return false;
+  if ($notnull_bool(!((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() {
@@ skipping 11 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 (n >= 100) return ("" + n + "");
-    if (n > 10) return ("0" + n + "");
+    if ($notnull_bool(n >= 100)) return ("" + n + "");
+    if ($notnull_bool(n > 10)) return ("0" + n + "");
     return ("00" + n + "");
   }
   function twoDigits(n) {
-    if (n >= 10) return ("" + n + "");
+    if ($notnull_bool(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 (this.timeZone.isUtc) {
+  if ($notnull_bool(this.timeZone.isUtc)) {
     return ("" + this.get$year() + "-" + m + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + "Z");
   }
   else {
     return ("" + this.get$year() + "-" + m + "-" + d + " " + h + ":" + min + ":" + sec + "." + ms + "");
   }
 }
 DateImplementation.prototype.add = function(duration) {
   return new DateImplementation.fromEpoch$ctor(this.value + duration.inMilliseconds, this.timeZone);
 }
 DateImplementation._now = function() {
   return new Date().valueOf();
 }
 DateImplementation.prototype._asJs = function() {
     if (!this.date) {
       this.date = new Date(this.value);
     }
     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 (!((other instanceof TimeZoneImplementation))) return false;
+  if ($notnull_bool(!((other instanceof TimeZoneImplementation)))) return false;
   return $eq(this.isUtc, other.isUtc);
 }
 TimeZoneImplementation.prototype.toString = function() {
-  if (this.isUtc) return "TimeZone (UTC)";
+  if ($notnull_bool(this.isUtc)) return "TimeZone (UTC)";
   return "TimeZone (Local)";
 }
 // ********** Code for top level **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
   this._start = _start;
   this._end = _end;
   this._groups = _groups;
   // Initializers done
@@ skipping 28 matching lines @@
 function createSandbox() {
   return {'require': require, 'process': process, 'console': console};
 }
 //  ********** 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 ($eq(piece, '..') && pieces.length > 0 && $ne(pieces.last(), '.') && $ne(pieces.last(), '..')) {
+    if ($notnull_bool($eq(piece, '..') && pieces.length > 0 && $ne(pieces.last(), '.') && $ne(pieces.last(), '..'))) {
       pieces.removeLast();
     }
-    else if ($ne(piece, '')) {
-      if (pieces.length > 0 && $eq(pieces.last(), '.')) {
+    else if ($notnull_bool($ne(piece, ''))) {
+      if ($notnull_bool(pieces.length > 0 && $eq(pieces.last(), '.'))) {
         pieces.removeLast();
       }
       pieces.add(piece);
     }
   }
-  return Strings.join(pieces, '/');
+  return Strings.join((pieces && pieces.is$List$String()), '/');
 }
 function dirname(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if ($notnull_bool(lastSlash == -1)) {
     return '.';
   }
   else {
     return path.substring(0, lastSlash);
   }
 }
 function basename(path) {
   var lastSlash = path.lastIndexOf('/', path.length);
-  if (lastSlash == -1) {
+  if ($notnull_bool(lastSlash == -1)) {
     return path;
   }
   else {
     return path.substring(lastSlash + 1);
   }
 }
 //  ********** Library file_system_node **************
 // ********** Code for NodeFileSystem **************
 function NodeFileSystem() {
   // Initializers done
@@ skipping 25 matching lines @@
 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();
   this.charOffset++;
   return next;
 }
 ArrayBasedScanner.prototype.select = function(choice, yes, no) {
   var next = this.advance();
-  if (next == choice) {
+  if ($notnull_bool(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 29 matching lines @@
   this.tail = this.tokens;
 }
 $inherits(ArrayBasedScanner$String, ArrayBasedScanner);
 ArrayBasedScanner$String.prototype.advance = function() {
   var next = this.nextByte();
   this.charOffset++;
   return next;
 }
 ArrayBasedScanner$String.prototype.select = function(choice, yes, no) {
   var next = this.advance();
-  if (next == choice) {
+  if ($notnull_bool(next == choice)) {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, yes);
     return this.advance();
   }
   else {
     this.appendStringToken(1024/*null.UNKNOWN_TOKEN*/, no);
     return next;
   }
 }
 ArrayBasedScanner$String.prototype.appendStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
@@ skipping 14 matching lines @@
   return this.tokens.next;
 }
 ArrayBasedScanner$String.prototype.addToCharOffset = function(offset) {
   this.charOffset += offset;
 }
 ArrayBasedScanner$String.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner$String.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while ($notnull_bool(next != -1)) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
 }
 ArrayBasedScanner$String.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 (next == -1) {
+      if ($notnull_bool(next == -1)) {
         return -1;
       }
-      if (next < 0x1f) {
+      if ($notnull_bool(next < 0x1f)) {
         $throw(new MalformedInputException(this.charOffset));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeTag = function(next) {
-  if (this.byteOffset == 0) {
-    if (this.peek() == 33/*null.$BANG*/) {
+  if ($notnull_bool(this.byteOffset == 0)) {
+    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
       do {
         next = this.advance();
       }
-      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
+      while ($notnull_bool(next != 10/*null.$LF*/ && next != 13/*null.$CR*/))
       return next;
     }
   }
   this.appendStringToken(35/*null.HASH_TOKEN*/, "#");
   return this.advance();
 }
 ArrayBasedScanner$String.prototype.tokenizeTilde = function(next) {
   next = this.advance();
-  if (next == 47/*null.$SLASH*/) {
+  if ($notnull_bool(next == 47/*null.$SLASH*/)) {
     return this.select(61/*null.$EQ*/, "~/=", "~/");
   }
   else {
     this.appendStringToken(126/*null.TILDE_TOKEN*/, "~");
     return next;
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeOpenBracket = function(next) {
   next = this.advance();
-  if (next == 93/*null.$RBRACKET*/) {
+  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendStringToken(93/*null.RBRACKET_TOKEN*/, "[");
     return next;
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeCaret = function(next) {
   return this.select(61/*null.$EQ*/, "^=", "^");
 }
@@ skipping 78 matching lines @@
 
     default:
 
       this.appendStringToken(43/*null.PLUS_TOKEN*/, "+");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeExclamation = function(next) {
   next = this.advance();
-  if (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(next == 61/*null.$EQ*/)) {
     return this.select(61/*null.$EQ*/, "!==", "!=");
   }
   this.appendStringToken(33/*null.BANG_TOKEN*/, "!");
   return next;
 }
 ArrayBasedScanner$String.prototype.tokenizeEquals = function(next) {
   next = this.advance();
-  if (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(next == 61/*null.$EQ*/)) {
     return this.select(61/*null.$EQ*/, "===", "==");
   }
   this.appendStringToken(61/*null.EQ_TOKEN*/, "=");
   return next;
 }
 ArrayBasedScanner$String.prototype.tokenizeGreaterThan = function(next) {
   next = this.advance();
   switch (next) {
     case 61/*null.$EQ*/:
 
@@ skipping 42 matching lines @@
 
     default:
 
       this.appendStringToken(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeNumber = function(next) {
   var start = this.byteOffset;
-  while (true) {
+  while ($notnull_bool(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$String.prototype.tokenizeHexOrNumber = function(next) {
   var x = this.peek();
-  if (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
+  if ($notnull_bool(x == 120/*null.$x*/ || x == 88/*null.$X*/)) {
     this.advance();
     return this.tokenizeHex(x);
   }
   return this.tokenizeNumber(next);
 }
 ArrayBasedScanner$String.prototype.tokenizeHex = function(next) {
   var start = this.byteOffset;
   var hasDigits = false;
-  while (true) {
+  while ($notnull_bool(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 (!hasDigits) {
+        if ($notnull_bool(!hasDigits)) {
           $throw(new MalformedInputException(this.charOffset));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.byteOffset;
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while (!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 (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
+  if ($notnull_bool(next == 100/*null.$d*/ || next == 68/*null.$D*/)) {
     next = this.advance();
   }
   this.appendByteStringToken(100/*null.DOUBLE_TOKEN*/, this.asciiString(start));
   return next;
 }
 ArrayBasedScanner$String.prototype.tokenizeExponent = function(next) {
-  if (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
+  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
     next = this.advance();
   }
   var hasDigits = false;
-  while (true) {
+  while ($notnull_bool(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 (!hasDigits) {
+        if ($notnull_bool(!hasDigits)) {
           $throw(new MalformedInputException(this.charOffset));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 12 matching lines @@
       return this.advance();
 
     default:
 
       this.appendStringToken(47/*null.SLASH_TOKEN*/, "/");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineComment = function(next) {
-  while (true) {
+  while ($notnull_bool(true)) {
     next = this.advance();
     switch (next) {
       case -1:
       case 10/*null.$LF*/:
       case 13/*null.$CR*/:
 
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineComment = function(next) {
   next = this.advance();
-  while (true) {
+  while ($notnull_bool(true)) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if (next == 47/*null.$SLASH*/) {
+        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if ($notnull_bool(next == -1)) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeIdentifier = function(next) {
   var start = this.byteOffset;
   var state = null;
-  if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while (true) {
-    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
-      if (state != null) {
+  while ($notnull_bool(true)) {
+    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+      if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    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*/) {
+    else if ($notnull_bool((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 (next < 128) {
-      if (state != null && state.isLeaf()) {
+    else if ($notnull_bool(next < 128)) {
+      if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
-      else if (isAscii) {
+      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 (next > 127)
+      while ($notnull_bool(next > 127))
       var string = this.utf8String(nonAsciiStart, -1).toString();
       isAscii = false;
       this.addToCharOffset(string.length);
       return next;
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeRawString = function(next) {
   var start = this.byteOffset;
   next = this.advance();
-  if (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
+  if ($notnull_bool(next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/)) {
     return this.tokenizeString(next, start, true);
   }
   else {
     $throw(new MalformedInputException(this.charOffset));
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeString = function(next, start, raw) {
   var q = next;
   next = this.advance();
-  if (q == next) {
+  if ($notnull_bool(q == next)) {
     next = this.advance();
-    if (q == next) {
+    if ($notnull_bool(q == next)) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
-  if (raw) {
+  if ($notnull_bool(raw)) {
     return this.tokenizeSingleLineRawString(next, q, start);
   }
   else {
     return this.tokenizeSingleLineString(next, q, start);
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineString = function(next, q1, start) {
-  while (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 92/*null.$BACKSLASH*/) {
+    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
       next = this.advance();
-      if (next == -1) {
+      if ($notnull_bool(next == -1)) {
         $throw(new MalformedInputException(this.charOffset));
       }
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeSingleLineRawString = function(next, q1, start) {
   next = this.advance();
-  while (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(next == 10/*null.$LF*/ || next == 13/*null.$CR*/)) {
       $throw(new MalformedInputException(this.charOffset));
     }
     next = this.advance();
   }
   $throw(new MalformedInputException(this.charOffset));
 }
 ArrayBasedScanner$String.prototype.tokenizeMultiLineString = function(q, start, raw) {
   var next = this.advance();
-  while (next != -1) {
-    if (next == q) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q)) {
       next = this.advance();
-      if (next == q) {
+      if ($notnull_bool(next == q)) {
         next = this.advance();
-        if (next == q) {
+        if ($notnull_bool(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 util_implementation **************
 // ********** Code for LinkFactory **************
 function LinkFactory() {}
 LinkFactory.Link$factory = function(head, tail) {
-  return new LinkEntry(head, (tail == null) ? const$227/*const EmptyLink<DeclarationBuilder>()*/ : tail);
+  var $0;
+  return new LinkEntry(head, (($0 = $notnull_bool((tail == null)) ? const$227/*const EmptyLink<DeclarationBuilder>()*/ : tail) && $0.is$Link$T()));
 }
 // ********** Code for AbstractLink **************
 function AbstractLink() {}
+AbstractLink.prototype.is$Link = function(){return this;};
+AbstractLink.prototype.is$Link$DeclarationBuilder = 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$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);
 }
 AbstractLink.prototype.iterator = function() {
   return this.toList().iterator();
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
-  if (this.isEmpty()) return;
+  var $0;
+  if ($notnull_bool(this.isEmpty())) return;
   buffer.add(this.get$head());
   for (var link = this.get$tail();
-   !link.isEmpty(); link = link.get$tail()) {
+   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link())) {
     buffer.add(separatedBy);
     buffer.add(link.get$head());
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 AbstractLink.prototype.printOn$1 = function($0) {
-  return this.printOn($0, '');
+  return this.printOn(($0 && $0.is$StringBuffer()), '');
 }
 ;
 // ********** Code for AbstractLink$T **************
 function AbstractLink$T() {}
 $inherits(AbstractLink$T, AbstractLink);
+AbstractLink$T.prototype.is$Link = function(){return this;};
+AbstractLink$T.prototype.is$Link$DeclarationBuilder = function(){return this;};
+AbstractLink$T.prototype.is$Link$Element = function(){return this;};
+AbstractLink$T.prototype.is$Link$Node = function(){return this;};
+AbstractLink$T.prototype.is$Link$T = function(){return this;};
+AbstractLink$T.prototype.is$Link$Type = function(){return this;};
+AbstractLink$T.prototype.is$Iterable = function(){return this;};
 AbstractLink$T.prototype.iterator = function() {
   return this.toList().iterator();
 }
 // ********** Code for LinkTail **************
 function LinkTail() {
   // Initializers done
 }
 $inherits(LinkTail, AbstractLink$T);
+LinkTail.prototype.is$Link = function(){return this;};
+LinkTail.prototype.is$Link$DeclarationBuilder = function(){return this;};
+LinkTail.prototype.is$Link$Element = function(){return this;};
+LinkTail.prototype.is$Link$Node = function(){return this;};
+LinkTail.prototype.is$Link$T = function(){return this;};
+LinkTail.prototype.is$Link$Type = function(){return this;};
+LinkTail.prototype.is$Iterable = function(){return this;};
 LinkTail.prototype.get$head = function() {
   return null;
 }
 LinkTail.prototype.get$tail = function() {
   return null;
 }
 LinkTail.prototype.toList = function() {
   return const$226/*const []*/;
 }
 LinkTail.prototype.isEmpty = function() {
   return true;
 }
 // ********** Code for LinkTail$DeclarationBuilder **************
 function LinkTail$DeclarationBuilder() {
   // Initializers done
 }
 $inherits(LinkTail$DeclarationBuilder, LinkTail);
+LinkTail$DeclarationBuilder.prototype.is$Link = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Link$DeclarationBuilder = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Link$Element = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Link$Node = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Link$T = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Link$Type = function(){return this;};
+LinkTail$DeclarationBuilder.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Element **************
 function LinkTail$Element() {
   // Initializers done
 }
 $inherits(LinkTail$Element, LinkTail);
+LinkTail$Element.prototype.is$Link = function(){return this;};
+LinkTail$Element.prototype.is$Link$DeclarationBuilder = function(){return this;};
+LinkTail$Element.prototype.is$Link$Element = function(){return this;};
+LinkTail$Element.prototype.is$Link$Node = function(){return this;};
+LinkTail$Element.prototype.is$Link$T = function(){return this;};
+LinkTail$Element.prototype.is$Link$Type = function(){return this;};
+LinkTail$Element.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkTail$Node **************
 function LinkTail$Node() {
   // Initializers done
 }
 $inherits(LinkTail$Node, LinkTail);
+LinkTail$Node.prototype.is$Link = function(){return this;};
+LinkTail$Node.prototype.is$Link$DeclarationBuilder = function(){return this;};
+LinkTail$Node.prototype.is$Link$Element = function(){return this;};
+LinkTail$Node.prototype.is$Link$Node = function(){return this;};
+LinkTail$Node.prototype.is$Link$T = function(){return this;};
+LinkTail$Node.prototype.is$Link$Type = function(){return this;};
+LinkTail$Node.prototype.is$Iterable = function(){return this;};
 // ********** Code for LinkEntry **************
 function LinkEntry(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
 $inherits(LinkEntry, AbstractLink$T);
 LinkEntry.prototype.get$head = function() { return this.head; };
 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;
-   !link.isEmpty(); link = link.get$tail()) {
+   $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 (this.head == null) return const$227/*const EmptyLink<DeclarationBuilder>()*/;
+  if ($notnull_bool(this.head == null)) return const$227/*const EmptyLink<DeclarationBuilder>()*/;
   this.lastLink.realTail = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   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 (this.head == null) {
+  if ($notnull_bool(this.head == null)) {
     this.head = entry;
   }
   else {
     this.lastLink.realTail = entry;
   }
   this.lastLink = entry;
 }
 // ********** Code for LinkBuilderImplementation$Type **************
 function LinkBuilderImplementation$Type() {
   this.head = null
   this.lastLink = null
   // Initializers done
 }
 $inherits(LinkBuilderImplementation$Type, LinkBuilderImplementation);
 // ********** Code for top level **************
 //  ********** Library util **************
 // ********** Code for top level **************
 //  ********** Library scanner **************
 // ********** Code for AbstractScanner **************
 function AbstractScanner() {}
 AbstractScanner.prototype.tokenize = function() {
   var next = this.advance();
-  while (next != -1) {
+  while ($notnull_bool(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 (next == -1) {
+      if ($notnull_bool(next == -1)) {
         return -1;
       }
-      if (next < 0x1f) {
+      if ($notnull_bool(next < 0x1f)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner.prototype.tokenizeTag = function(next) {
-  if (this.get$byteOffset() == 0) {
-    if (this.peek() == 33/*null.$BANG*/) {
+  if ($notnull_bool(this.get$byteOffset() == 0)) {
+    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
       do {
         next = this.advance();
       }
-      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
+      while ($notnull_bool(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 (next == 47/*null.$SLASH*/) {
+  if ($notnull_bool(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 (next == 93/*null.$RBRACKET*/) {
+  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendStringToken(93/*null.RBRACKET_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 (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(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 (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(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*/:
 
@@ skipping 42 matching lines @@
 
     default:
 
       this.appendStringToken(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
-  while (true) {
+  while ($notnull_bool(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 (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
+  if ($notnull_bool(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 (true) {
+  while ($notnull_bool(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 (!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 (!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 (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
+  if ($notnull_bool(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 (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
+  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
     next = this.advance();
   }
   var hasDigits = false;
-  while (true) {
+  while ($notnull_bool(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 (!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 (true) {
+  while ($notnull_bool(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 (true) {
+  while ($notnull_bool(true)) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if (next == 47/*null.$SLASH*/) {
+        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if ($notnull_bool(next == -1)) {
           return next;
         }
         break;
 
       default:
 
         next = this.advance();
         break;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeIdentifier = function(next) {
   var start = this.get$byteOffset();
   var state = null;
-  if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while (true) {
-    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
-      if (state != null) {
+  while ($notnull_bool(true)) {
+    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+      if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    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*/) {
+    else if ($notnull_bool((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 (next < 128) {
-      if (state != null && state.isLeaf()) {
+    else if ($notnull_bool(next < 128)) {
+      if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
-      else if (isAscii) {
+      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 (next > 127)
+      while ($notnull_bool(next > 127))
       var 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 (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
+  if ($notnull_bool(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 (q == next) {
+  if ($notnull_bool(q == next)) {
     next = this.advance();
-    if (q == next) {
+    if ($notnull_bool(q == next)) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
-  if (raw) {
+  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 (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 92/*null.$BACKSLASH*/) {
+    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
       next = this.advance();
-      if (next == -1) {
+      if ($notnull_bool(next == -1)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(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 (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(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 (next != -1) {
-    if (next == q) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q)) {
       next = this.advance();
-      if (next == q) {
+      if ($notnull_bool(next == q)) {
         next = this.advance();
-        if (next == q) {
+        if ($notnull_bool(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 (next != -1) {
+  while ($notnull_bool(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 (next == -1) {
+      if ($notnull_bool(next == -1)) {
         return -1;
       }
-      if (next < 0x1f) {
+      if ($notnull_bool(next < 0x1f)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
       return this.tokenizeIdentifier(next);
 
   }
 }
 AbstractScanner$S.prototype.tokenizeTag = function(next) {
-  if (this.get$byteOffset() == 0) {
-    if (this.peek() == 33/*null.$BANG*/) {
+  if ($notnull_bool(this.get$byteOffset() == 0)) {
+    if ($notnull_bool(this.peek() == 33/*null.$BANG*/)) {
       do {
         next = this.advance();
       }
-      while (next != 10/*null.$LF*/ && next != 13/*null.$CR*/)
+      while ($notnull_bool(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 (next == 47/*null.$SLASH*/) {
+  if ($notnull_bool(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 (next == 93/*null.$RBRACKET*/) {
+  if ($notnull_bool(next == 93/*null.$RBRACKET*/)) {
     return this.select(61/*null.$EQ*/, "[]=", "[]");
   }
   else {
     this.appendStringToken(93/*null.RBRACKET_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 (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(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 (next == 61/*null.$EQ*/) {
+  if ($notnull_bool(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*/:
 
@@ skipping 42 matching lines @@
 
     default:
 
       this.appendStringToken(60/*null.LT_TOKEN*/, "<");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeNumber = function(next) {
   var start = this.get$byteOffset();
-  while (true) {
+  while ($notnull_bool(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 (x == 120/*null.$x*/ || x == 88/*null.$X*/) {
+  if ($notnull_bool(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 (true) {
+  while ($notnull_bool(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 (!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 (!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 (next == 100/*null.$d*/ || next == 68/*null.$D*/) {
+  if ($notnull_bool(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 (next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/) {
+  if ($notnull_bool(next == 43/*null.$PLUS*/ || next == 45/*null.$MINUS*/)) {
     next = this.advance();
   }
   var hasDigits = false;
-  while (true) {
+  while ($notnull_bool(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 (!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 (true) {
+  while ($notnull_bool(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 (true) {
+  while ($notnull_bool(true)) {
     switch (next) {
       case -1:
 
         return next;
 
       case 42/*null.$STAR*/:
 
         next = this.advance();
-        if (next == 47/*null.$SLASH*/) {
+        if ($notnull_bool(next == 47/*null.$SLASH*/)) {
           return this.advance();
         }
-        else if (next == -1) {
+        else if ($notnull_bool(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 (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
+  if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
-  while (true) {
-    if (97/*null.$a*/ <= next && next <= 122/*null.$z*/) {
-      if (state != null) {
+  while ($notnull_bool(true)) {
+    if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
+      if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    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*/) {
+    else if ($notnull_bool((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 (next < 128) {
-      if (state != null && state.isLeaf()) {
+    else if ($notnull_bool(next < 128)) {
+      if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
-      else if (isAscii) {
+      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 (next > 127)
+      while ($notnull_bool(next > 127))
       var 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 (next == 34/*null.$DQ*/ || next == 39/*null.$SQ*/) {
+  if ($notnull_bool(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 (q == next) {
+  if ($notnull_bool(q == next)) {
     next = this.advance();
-    if (q == next) {
+    if ($notnull_bool(q == next)) {
       return this.tokenizeMultiLineString(q, start, raw);
     }
     else {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, -1));
       return next;
     }
   }
-  if (raw) {
+  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 (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 92/*null.$BACKSLASH*/) {
+    else if ($notnull_bool(next == 92/*null.$BACKSLASH*/)) {
       next = this.advance();
-      if (next == -1) {
+      if ($notnull_bool(next == -1)) {
         $throw(new MalformedInputException(this.get$charOffset()));
       }
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(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 (next != -1) {
-    if (next == q1) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q1)) {
       this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
       return this.advance();
     }
-    else if (next == 10/*null.$LF*/ || next == 13/*null.$CR*/) {
+    else if ($notnull_bool(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 (next != -1) {
-    if (next == q) {
+  while ($notnull_bool(next != -1)) {
+    if ($notnull_bool(next == q)) {
       next = this.advance();
-      if (next == q) {
+      if ($notnull_bool(next == q)) {
         next = this.advance();
-        if (next == q) {
+        if ($notnull_bool(next == q)) {
           this.appendByteStringToken(39/*null.STRING_TOKEN*/, this.utf8String(start, 0));
           return this.advance();
         }
       }
     }
     next = this.advance();
   }
   return next;
 }
 // ********** Code for MalformedInputException **************
 function MalformedInputException(ignored) {
   // Initializers done
 }
 // ********** Code for Parser **************
 function Parser(listener) {
   this.listener = listener;
   // Initializers done
 }
 Parser.prototype.next = function(token) {
   return this.checkEof(token.next);
 }
 Parser.prototype.checkEof = function(token) {
-  if (token.kind == 0/*null.EOF_TOKEN*/) {
+  if ($notnull_bool(token.kind == 0/*null.EOF_TOKEN*/)) {
     this.listener.unexpectedEof();
     $throw("Unexpected EOF");
   }
   return token;
 }
 Parser.prototype.parseUnit = function(token) {
-  while (token.kind != 0/*null.EOF_TOKEN*/) {
+  while ($notnull_bool(token.kind != 0/*null.EOF_TOKEN*/)) {
     switch (token.get$value()) {
       case const$203/*Keyword.INTERFACE*/:
 
         token = this.parseInterface(token);
         break;
 
       case const$191/*Keyword.CLASS*/:
 
         token = this.parseClass(token);
         break;
 
       case const$219/*Keyword.TYPEDEF*/:
 
         token = this.parseNamedFunctionAlias(token);
         break;
 
       default:
 
-        if ($eq(token.get$value(), const$237/*const SourceString("#")*/)) {
+        if ($notnull_bool($eq(token.get$value(), const$237/*const SourceString("#")*/))) {
           token = this.parseLibraryTags(token);
         }
         else {
           token = this.parseTopLevelMember(token);
         }
         break;
 
     }
   }
 }
@@ skipping 13 matching lines @@
 Parser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
   token = this.parseParameters(token);
   this.listener.endFunctionTypeAlias(token);
   return this.expect(const$236/*const SourceString(";")*/, token);
 }
 Parser.prototype.parseReturnTypeOpt = function(token) {
-  if ($eq(token.get$value(), const$183/*Keyword.VOID*/)) {
+  if ($notnull_bool($eq(token.get$value(), const$183/*Keyword.VOID*/))) {
     this.listener.voidType(token);
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
 Parser.prototype.parseParameters = function(token) {
   this.expect(const$234/*const SourceString("(")*/, token);
-  if (this.optional(const$235/*const SourceString(")")*/, this.next(token))) {
+  if ($notnull_bool(this.optional(const$235/*const SourceString(")")*/, this.next(token)))) {
     return this.next(this.next(token));
   }
   do {
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
   }
-  while (this.optional(const$230/*const SourceString(",")*/, token))
+  while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   return this.expect(const$235/*const SourceString(")")*/, token);
 }
 Parser.prototype.parseTypeOpt = function(token) {
   switch (true) {
     case this.optional(const$228/*const SourceString("<")*/, this.next(token)):
     case this.optional(const$229/*const SourceString(".")*/, this.next(token)):
     case this.isIdentifier(this.next(token)):
 
       return this.parseType(token);
 
@@ skipping 13 matching lines @@
 
       return token.get$value().isPseudo;
 
     default:
 
       return false;
 
   }
 }
 Parser.prototype.parseSupertypesClauseOpt = function(token) {
-  if (this.optional(const$193/*Keyword.EXTENDS*/, token)) {
+  if ($notnull_bool(this.optional(const$193/*Keyword.EXTENDS*/, token))) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$230/*const SourceString(",")*/, token))
+    while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   }
   return token;
 }
 Parser.prototype.parseFactoryClauseOpt = function(token) {
-  if (this.optional(const$195/*Keyword.FACTORY*/, token)) {
+  if ($notnull_bool(this.optional(const$195/*Keyword.FACTORY*/, token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 Parser.prototype.skipBlock = function(token) {
-  if (!this.optional(const$232/*const SourceString("{")*/, token)) {
+  if ($notnull_bool(!this.optional(const$232/*const SourceString("{")*/, token))) {
     return this.listener.expectedBlock(token);
   }
   token = this.next(token);
   var nesting = 1;
   do {
     switch (token.kind) {
       case 123/*null.LBRACE_TOKEN*/:
 
         nesting++;
         break;
 
       case 125/*null.RBRACE_TOKEN*/:
 
         nesting--;
-        if (nesting == 0) {
+        if ($notnull_bool(nesting == 0)) {
           return token;
         }
         break;
 
     }
     token = this.next(token);
   }
-  while (token != null)
+  while ($notnull_bool(token != null))
   $throw("Internal error: unreachable code");
 }
 Parser.prototype.parseClass = function(token) {
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSuperclassClauseOpt(token);
   token = this.parseImplementsOpt(token);
   token = this.parseNativeClassClauseOpt(token);
   return this.parseClassBody(token);
 }
 Parser.prototype.parseNativeClassClauseOpt = function(token) {
-  if (this.optional(const$207/*Keyword.NATIVE*/, token)) {
+  if ($notnull_bool(this.optional(const$207/*Keyword.NATIVE*/, token))) {
     return this.parseString(this.next(token));
   }
   return token;
 }
 Parser.prototype.parseString = function(token) {
   switch (token.kind) {
     case 39/*null.STRING_TOKEN*/:
 
       return this.next(token);
 
     default:
 
       return this.listener.expected(const$233/*const SourceString("string")*/, token);
 
   }
 }
 Parser.prototype.parseIdentifier = function(token) {
-  if (this.isIdentifier(token)) {
+  if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.identifier(token);
   }
   else {
     this.listener.notIdentifier(token);
   }
   return this.next(token);
 }
 Parser.prototype.parseTypeVariablesOpt = function(token) {
-  if (!this.optional(const$228/*const SourceString("<")*/, token)) {
+  if ($notnull_bool(!this.optional(const$228/*const SourceString("<")*/, token))) {
     return token;
   }
   this.listener.beginTypeVariables(token);
   do {
     token = this.parseTypeVariable(this.next(token));
   }
-  while (this.optional(const$230/*const SourceString(",")*/, token))
+  while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   return this.expect(const$231/*const SourceString(">")*/, token);
 }
 Parser.prototype.expect = function(string, token) {
-  if ($ne(string, token.get$value())) {
+  if ($notnull_bool($ne(string, token.get$value()))) {
     return this.listener.expected(string, token);
   }
   return token.next;
 }
 Parser.prototype.parseTypeVariable = function(token) {
   this.listener.beginTypeVariable(token);
   token = this.parseIdentifier(token);
   token = this.parseSuperclassClauseOpt(token);
   this.listener.endTypeVariable(token);
   return token;
 }
 Parser.prototype.optional = function(value, token) {
   return $eq(value, token.get$value());
 }
 Parser.prototype.parseSuperclassClauseOpt = function(token) {
-  if (this.optional(const$193/*Keyword.EXTENDS*/, token)) {
+  if ($notnull_bool(this.optional(const$193/*Keyword.EXTENDS*/, token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 Parser.prototype.parseType = function(token) {
-  if (this.isIdentifier(token)) {
+  if ($notnull_bool(this.isIdentifier(token))) {
     token = this.parseIdentifier(token);
-    while (this.optional(const$229/*const SourceString(".")*/, token)) {
+    while ($notnull_bool(this.optional(const$229/*const SourceString(".")*/, token))) {
       token = this.parseIdentifier(this.next(token));
     }
   }
   else {
     token = this.listener.expectedType(token);
   }
   return this.parseTypeArgumentsOpt(token);
 }
 Parser.prototype.parseTypeArgumentsOpt = function(token) {
-  if (this.optional(const$228/*const SourceString("<")*/, token)) {
+  if ($notnull_bool(this.optional(const$228/*const SourceString("<")*/, token))) {
     this.listener.beginTypeArguments(this.next(token));
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$230/*const SourceString(",")*/, token))
+    while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
     return this.expect(const$231/*const SourceString(">")*/, token);
   }
   return token;
 }
 Parser.prototype.parseImplementsOpt = function(token) {
-  if (this.optional(const$199/*Keyword.IMPLEMENTS*/, token)) {
+  if ($notnull_bool(this.optional(const$199/*Keyword.IMPLEMENTS*/, token))) {
     do {
       token = this.parseType(this.next(token));
     }
-    while (this.optional(const$230/*const SourceString(",")*/, token))
+    while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   }
   return token;
 }
 Parser.prototype.parseClassBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endClass(token);
   return token.next;
 }
 Parser.prototype.parseTopLevelMember = function(token) {
   var start = token;
   this.listener.beginTopLevelMember(token);
   var previous = token;
   LOOP:
-  while (token != null) {
+  while ($notnull_bool(token != null)) {
     switch (token.kind) {
       case 123/*null.LBRACE_TOKEN*/:
       case 59/*null.SEMICOLON_TOKEN*/:
       case 40/*null.LPAREN_TOKEN*/:
       case 61/*null.EQ_TOKEN*/:
 
         break LOOP;
 
       default:
 
         previous = token;
         token = this.next(token);
         break;
 
     }
   }
   token = this.parseIdentifier(previous);
-  if (this.optional(const$234/*const SourceString("(")*/, token)) {
+  if ($notnull_bool(this.optional(const$234/*const SourceString("(")*/, token))) {
     this.listener.topLevelMethod(start);
   }
-  else if (this.optional(const$238/*const SourceString("=")*/, token) || this.optional(const$236/*const SourceString(";")*/, token)) {
+  else if ($notnull_bool(this.optional(const$238/*const SourceString("=")*/, token) || this.optional(const$236/*const SourceString(";")*/, token))) {
     this.listener.topLevelField(start);
   }
   else {
     token = this.listener.unexpected(token);
   }
-  while (token != null && token.kind != 123/*null.LBRACE_TOKEN*/ && token.kind != 59/*null.SEMICOLON_TOKEN*/) {
+  while ($notnull_bool(token != null && token.kind != 123/*null.LBRACE_TOKEN*/ && token.kind != 59/*null.SEMICOLON_TOKEN*/)) {
     token = this.next(token);
   }
-  if (!this.optional(const$236/*const SourceString(";")*/, token)) {
+  if ($notnull_bool(!this.optional(const$236/*const SourceString(";")*/, token))) {
     token = this.skipBlock(token);
   }
   this.listener.endTopLevelMember(token);
   return token.next;
 }
 Parser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect(const$234/*const SourceString("(")*/, token);
-  while (token != null && token.kind != 40/*null.LPAREN_TOKEN*/ && token.kind != 41/*null.RPAREN_TOKEN*/) {
+  while ($notnull_bool(token != null && token.kind != 40/*null.LPAREN_TOKEN*/ && token.kind != 41/*null.RPAREN_TOKEN*/)) {
     token = this.next(token);
   }
   token = this.expect(const$235/*const SourceString(")")*/, token);
   return this.expect(const$236/*const SourceString(";")*/, token);
 }
 // ********** Code for BodyParser **************
 function BodyParser(listener0) {
   Parser.call(this, listener0);
   // Initializers done
 }
 $inherits(BodyParser, Parser);
 BodyParser.prototype.parseFunction = function(token) {
   this.listener.beginFunction(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName(token);
   token = this.parseFormalParameters(token);
   return this.parseFunctionBody(token);
 }
 BodyParser.prototype.parseFormalParameters = function(token) {
   var begin = token;
   this.listener.beginFormalParameters(begin);
   this.expect(const$234/*const SourceString("(")*/, token);
   var parameterCount = 0;
-  if (this.optional(const$235/*const SourceString(")")*/, token.next)) {
+  if ($notnull_bool(this.optional(const$235/*const SourceString(")")*/, token.next))) {
     this.listener.endFormalParameters(parameterCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseType(this.next(token));
     token = this.parseIdentifier(token);
     ++parameterCount;
   }
-  while (this.optional(const$230/*const SourceString(",")*/, token))
+  while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   this.listener.endFormalParameters(parameterCount, begin, token);
   return this.expect(const$235/*const SourceString(")")*/, token);
 }
 BodyParser.prototype.parseFunctionBody = function(token) {
-  if (this.optional(const$236/*const SourceString(";")*/, token)) {
+  if ($notnull_bool(this.optional(const$236/*const SourceString(";")*/, 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(const$232/*const SourceString("{")*/, token));
-  while (!this.optional(const$239/*const SourceString("}")*/, token)) {
+  while ($notnull_bool(!this.optional(const$239/*const SourceString("}")*/, token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endFunctionBody(statementCount, begin, token);
   return this.expect(const$239/*const SourceString("}")*/, token);
 }
 BodyParser.prototype.parseStatement = function(token) {
   this.checkEof(token);
-  if ($eq(token.get$value(), const$240/*const SourceString('{')*/)) {
+  if ($notnull_bool($eq(token.get$value(), const$240/*const SourceString('{')*/))) {
     return this.parseBlock(token);
   }
   switch (token.get$value()) {
     case const$167/*Keyword.RETURN*/:
 
       return this.parseReturnStatement(token);
 
     case const$181/*Keyword.VAR*/:
 
       return this.parseVariablesDeclaration(token);
 
     case const$157/*Keyword.IF*/:
 
       return this.parseIfStatement(token);
 
     default:
 
       return this.parseExpressionStatement(token);
 
   }
 }
 BodyParser.prototype.expectSemicolon = function(token) {
   return this.expect(const$236/*const SourceString(";")*/, token);
 }
 BodyParser.prototype.parseReturnStatement = function(token) {
   var begin = token;
   this.listener.beginReturnStatement(begin);
+  $assert($eq(const$241/*const SourceString("return")*/, token.get$value()), "const SourceString(\"return\") == token.value", "leg/scanner/parser.dart", 393, 12);
   token = this.parseExpression(this.next(token));
   this.listener.endReturnStatement(true, begin, token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseExpressionStatement = function(token) {
   this.listener.beginExpressionStatement(token);
   token = this.parseExpression(token);
   this.listener.endExpressionStatement(token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseExpression = function(token) {
   token = this.parseConditionalExpression(token);
-  if (this.isAssignmentOperator(token)) {
+  if ($notnull_bool(this.isAssignmentOperator(token))) {
     var operator = token;
     token = this.parseExpression(this.next(token));
     this.listener.handleAssignmentExpression(operator);
   }
   return token;
 }
 BodyParser.prototype.isAssignmentOperator = function(token) {
   return 2 == this.getPrecedence(token);
 }
 BodyParser.prototype.parseConditionalExpression = function(token) {
   token = this.parseBinaryExpression(token, 4);
-  if (this.optional(const$242/*const SourceString("?")*/, token)) {
+  if ($notnull_bool(this.optional(const$242/*const SourceString("?")*/, token))) {
     var question = token;
     token = this.parseExpression(this.next(token));
     var colon = token;
     token = this.expect(const$243/*const SourceString(":")*/, token);
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression(question, colon);
   }
   return token;
 }
 BodyParser.prototype.parseBinaryExpression = function(token, precedence) {
+  $assert(precedence >= 4, "precedence >= 4", "leg/scanner/parser.dart", 434, 12);
   token = this.parsePrimary(token);
   for (var level = this.getPrecedence(token);
-   level >= precedence; --level) {
-    while (this.getPrecedence(token) == level) {
+   $notnull_bool(level >= precedence); --level) {
+    while ($notnull_bool(this.getPrecedence(token) == level)) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression(operator);
     }
   }
   return token;
 }
 BodyParser.prototype.getPrecedence = function(token) {
-  if (token == null) return 0;
+  if ($notnull_bool(token == null)) return 0;
   var value = token.get$value();
-  if (!(value instanceof StringWrapper)) return 0;
+  if ($notnull_bool(!(value instanceof StringWrapper))) return 0;
   switch (value.toString()) {
     case "%=":
 
       return 2;
 
     case "&=":
 
       return 2;
 
     case "*=":
@@ skipping 202 matching lines @@
   return token.next;
 }
 BodyParser.prototype.parseSend = function(token) {
   this.listener.beginSend(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend(token);
   return token;
 }
 BodyParser.prototype.parseArgumentsOpt = function(token) {
-  if (!this.optional(const$234/*const SourceString("(")*/, token)) {
+  if ($notnull_bool(!this.optional(const$234/*const SourceString("(")*/, token))) {
     this.listener.handleNoArgumentsOpt(token);
     return token;
   }
   else return this.parseArguments(token);
 }
 BodyParser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
+  $assert($eq(const$234/*const SourceString("(")*/, token.get$value()), "const SourceString(\"(\") == token.value", "leg/scanner/parser.dart", 559, 12);
   var argumentCount = 0;
-  if (this.optional(const$235/*const SourceString(")")*/, token.next)) {
+  if ($notnull_bool(this.optional(const$235/*const SourceString(")")*/, token.next))) {
     this.listener.endArguments(argumentCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseExpression(this.next(token));
     ++argumentCount;
   }
-  while (this.optional(const$230/*const SourceString(",")*/, token))
+  while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   this.listener.endArguments(argumentCount, begin, token);
   return this.expect(const$235/*const SourceString(")")*/, token);
 }
 BodyParser.prototype.parseVariablesDeclaration = function(token) {
   var count = 1;
   this.listener.beginVariablesDeclaration(token);
   token = this.parseFinalVarOrType(token);
   token = this.parseOptionallyInitializedIdentifier(token);
-  while (this.optional(const$245/*const SourceString(',')*/, token)) {
+  while ($notnull_bool(this.optional(const$245/*const SourceString(',')*/, token))) {
     token = this.parseOptionallyInitializedIdentifier(this.next(token));
     ++count;
   }
   this.listener.endVariablesDeclaration(count, token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseOptionallyInitializedIdentifier = function(token) {
   this.listener.beginInitializedIdentifier(token);
   token = this.parseIdentifier(token);
-  if (this.optional(const$244/*const SourceString('=')*/, token)) {
+  if ($notnull_bool(this.optional(const$244/*const SourceString('=')*/, token))) {
     var assignment = token;
     this.listener.beginInitializer(token);
     token = this.parseExpression(this.next(token));
     this.listener.endInitializer(assignment);
   }
   this.listener.endInitializedIdentifier();
   return token;
 }
 BodyParser.prototype.parseFinalVarOrType = function(token) {
   this.listener.handleVarKeyword(token);
   return this.expect(const$181/*Keyword.VAR*/, token);
 }
 BodyParser.prototype.parseIfStatement = function(token) {
   var ifToken = token;
   this.listener.beginIfStatement(ifToken);
   token = this.expect(const$157/*Keyword.IF*/, token);
   this.expect(const$246/*const SourceString('(')*/, token);
   token = this.parseArguments(token);
   token = this.parseStatement(token);
   var elseToken = null;
-  if (this.optional(const$147/*Keyword.ELSE*/, token)) {
+  if ($notnull_bool(this.optional(const$147/*Keyword.ELSE*/, token))) {
     elseToken = token;
     token = this.parseStatement(token.next);
   }
   this.listener.endIfStatement(ifToken, elseToken);
   return token;
 }
 BodyParser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock(begin);
   var statementCount = 0;
   token = this.expect(const$240/*const SourceString('{')*/, token);
-  while (!this.optional(const$239/*const SourceString("}")*/, token)) {
+  while ($notnull_bool(!this.optional(const$239/*const SourceString("}")*/, token))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endBlock(statementCount, begin, token);
   return this.expect(const$239/*const SourceString("}")*/, token);
 }
 // ********** Code for Listener **************
 function Listener(canceler) {
   this.classCount = 0
   this.aliasCount = 0
@@ skipping 102 matching lines @@
 Listener.prototype.expectedType = function(token) {
   this.canceler.cancel(("Expected a type, but got '" + token + "' @ " + token.charOffset + ""));
 }
 Listener.prototype.expectedBlock = function(token) {
   this.canceler.cancel(("Expected a block, but got '" + token + "' @ " + token.charOffset + ""));
 }
 Listener.prototype.unexpected = function(token) {
   this.canceler.cancel(("Unexpected token '" + token + "' @ " + token.charOffset + ""));
 }
 Listener.prototype.push = function(token, builder) {
-  this.builders = this.builders.prepend(new DeclarationBuilder(token, builder));
+  var $0;
+  this.builders = (($0 = this.builders.prepend(new DeclarationBuilder(token, builder))) && $0.is$Link$DeclarationBuilder());
 }
 Listener.prototype.addElement = function(element) {
-  this.topLevelElements = this.topLevelElements.prepend(element);
+  var $0;
+  this.topLevelElements = (($0 = this.topLevelElements.prepend(element)) && $0.is$Link$Element());
 }
 Listener.prototype.pop = function() {
+  var $0;
   var declaration = this.builders.get$head();
-  this.builders = this.builders.get$tail();
+  this.builders = (($0 = this.builders.get$tail()) && $0.is$Link$DeclarationBuilder());
   return declaration;
 }
 Listener.prototype.handleDeclaration = function(declaration, token) {
   declaration.endToken = token;
   declaration.endToken = token;
   this.addElement(declaration.build());
 }
 Listener.prototype.voidType = function(token) {
 
 }
@@ skipping 28 matching lines @@
 BodyListener.prototype.endArguments = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
 BodyListener.prototype.handleNoArgumentsOpt = function(token) {
   this.pushNode(null);
 }
 BodyListener.prototype.beginReturnStatement = function(token) {
 
 }
 BodyListener.prototype.endReturnStatement = function(hasExpression, beginToken, endToken) {
-  var expression = hasExpression ? this.popNode() : null;
+  var expression = $notnull_bool(hasExpression) ? this.popNode() : null;
   this.pushNode(new Return(beginToken, endToken, expression));
 }
 BodyListener.prototype.beginExpressionStatement = function(token) {
 
 }
 BodyListener.prototype.endExpressionStatement = function(token) {
   this.pushNode(new ExpressionStatement(this.popNode(), token));
 }
 BodyListener.prototype.onError = function(token, error) {
   this.canceler.cancel(("internal error @ " + token.charOffset + ": '" + token.get$value() + "'") + (": " + error + ""));
@@ skipping 13 matching lines @@
 BodyListener.prototype.handleLiteralString = function(token) {
   this.pushNode(new LiteralString(token));
 }
 BodyListener.prototype.handleBinaryExpression = function(token) {
   var arguments = new NodeList(null, LinkFactory.Link$factory(this.popNode()), null, null);
   this.pushNode(new Send(this.popNode(), new Operator(token), arguments));
 }
 BodyListener.prototype.handleAssignmentExpression = function(token) {
   var arguments = new NodeList.singleton$ctor(this.popNode());
   var node = this.popNode();
-  if (!(node instanceof Send)) this.canceler.cancel(('not assignable: ' + node + ''));
+  if ($notnull_bool(!(node instanceof Send))) this.canceler.cancel(('not assignable: ' + node + ''));
   var send = node;
-  if (!send.get$isPropertyAccess()) this.canceler.cancel(('not assignable: ' + node + ''));
-  if ((send instanceof SetterSend)) this.canceler.cancel('chained assignment');
+  if ($notnull_bool(!send.get$isPropertyAccess())) this.canceler.cancel(('not assignable: ' + node + ''));
+  if ($notnull_bool((send instanceof SetterSend))) this.canceler.cancel('chained assignment');
   this.pushNode(new SetterSend(send.receiver, send.selector, token, arguments));
 }
 BodyListener.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');
 }
 BodyListener.prototype.beginSend = function(token) {
 
@@ skipping 15 matching lines @@
 BodyListener.prototype.beginFunctionName = function(token) {
 
 }
 BodyListener.prototype.endFunctionName = function(token) {
 
 }
 BodyListener.prototype.beginFunctionBody = function(token) {
 
 }
 BodyListener.prototype.endFunctionBody = function(count, beginToken, endToken) {
+  var $0;
   var block = new Block(this.makeNodeList(count, beginToken, endToken, null));
   var formals = this.popNode();
   var name = this.popNode();
-  var type = new TypeAnnotation(this.popNode());
+  var type = new TypeAnnotation((($0 = this.popNode()) && $0.is$Identifier()));
   this.pushNode(new FunctionExpression(name, formals, block, type));
 }
 BodyListener.prototype.beginVariablesDeclaration = function(token) {
 
 }
 BodyListener.prototype.endVariablesDeclaration = function(count, endToken) {
   var variables = this.makeNodeList(count, null, null, ",");
   this.pushNode(new VariableDefinitions(null, null, variables, endToken));
 }
 BodyListener.prototype.beginInitializedIdentifier = function(token) {
@@ skipping 12 matching lines @@
   var name = this.popNode();
   this.pushNode(new Send(name, operator, arguments));
 }
 BodyListener.prototype.handleVarKeyword = function(token) {
 
 }
 BodyListener.prototype.beginIfStatement = function(token) {
 
 }
 BodyListener.prototype.endIfStatement = function(ifToken, elseToken) {
-  var elsePart = (elseToken == null) ? null : this.popNode();
+  var elsePart = $notnull_bool((elseToken == null)) ? null : this.popNode();
   var thenPart = this.popNode();
   var condition = this.popNode();
   this.pushNode(new If(condition, thenPart, elsePart, ifToken, elseToken));
 }
 BodyListener.prototype.beginBlock = function(token) {
 
 }
 BodyListener.prototype.endBlock = function(count, beginToken, endToken) {
   this.pushNode(new Block(this.makeNodeList(count, beginToken, endToken, null)));
 }
 BodyListener.prototype.pushNode = function(node) {
-  this.nodes = this.nodes.prepend(node);
+  var $0;
+  this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link$Node());
   this.logger.log(("push " + this.nodes + ""));
 }
 BodyListener.prototype.popNode = function() {
+  var $0;
+  $assert(!this.nodes.isEmpty(), "!nodes.isEmpty()", "leg/scanner/listener.dart", 360, 12);
   var node = this.nodes.get$head();
-  this.nodes = this.nodes.get$tail();
+  this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link$Node());
   this.logger.log(("pop " + this.nodes + ""));
   return node;
 }
 BodyListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
+  var $0;
   var nodes0 = const$227/*const EmptyLink<DeclarationBuilder>()*/;
-  for (; count > 0; --count) {
-    nodes0 = nodes0.prepend(this.popNode());
+  for (; $notnull_bool(count > 0); --count) {
+    nodes0 = (($0 = nodes0.prepend(this.popNode())) && $0.is$Link$Node());
   }
-  var sourceDelimiter = (delimiter == null) ? null : new StringWrapper(delimiter);
+  var sourceDelimiter = $notnull_bool((delimiter == null)) ? null : new StringWrapper(delimiter);
   return new NodeList(beginToken, nodes0, endToken, sourceDelimiter);
 }
 // ********** Code for PartialFunctionElement **************
 function PartialFunctionElement(name0, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   FunctionElement.call(this, name0);
   // Initializers done
 }
 $inherits(PartialFunctionElement, FunctionElement);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
-  if (this.node != null) return this.node;
+  var $0;
+  if ($notnull_bool(this.node != null)) return this.node;
   var listener = new BodyListener(canceler, logger);
   new BodyParser(listener).parseFunction(this.beginToken);
-  this.node = listener.popNode();
+  this.node = (($0 = listener.popNode()) && $0.is$FunctionExpression());
   logger.log(("parsed function: " + this.node + ""));
   return this.node;
 }
 // ********** Code for StringScanner **************
 function StringScanner(string) {
   this.string = string;
   ArrayBasedScanner$String.call(this);
   // Initializers done
 }
 $inherits(StringScanner, ArrayBasedScanner$String);
 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 (this.string.length > index) ? this.string.charCodeAt(index) : -1;
+  return $notnull_bool((this.string.length > $assert_num(index))) ? this.string.charCodeAt(index) : -1;
 }
 StringScanner.prototype.asciiString = function(start) {
   return this.string.substring(start, this.byteOffset);
 }
 StringScanner.prototype.utf8String = function(start, offset) {
   return this.string.substring(start, this.byteOffset + offset + 1);
 }
 StringScanner.prototype.appendByteStringToken = function(kind, value) {
   this.tail.next = new StringToken(kind, value, this.tokenStart);
   this.tail = this.tail.next;
@@ skipping 44 matching lines @@
 }
 StringWrapper.prototype.$eq = function(other) {
   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.printOn$1 = StringWrapper.prototype.printOn;
+StringWrapper.prototype.printOn$1 = function($0) {
+  return this.printOn(($0 && $0.is$StringBuffer()));
+}
+;
 // ********** 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 (Keyword._keywords == null) {
+  if ($notnull_bool(Keyword._keywords == null)) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
+  var $0;
   var result = new LinkedHashMapImplementation$String$Keyword();
   for (var $i0 = const$222/*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 !!(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.printOn$1 = Keyword.prototype.printOn;
+Keyword.prototype.printOn$1 = function($0) {
+  return this.printOn(($0 && $0.is$StringBuffer()));
+}
+;
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.get$KEYWORD_STATE = function() {
-  if (KeywordState._KEYWORD_STATE == null) {
+  if ($notnull_bool(KeywordState._KEYWORD_STATE == null)) {
     var strings = new ListFactory$String(const$222/*Keyword.values*/.get$length());
     for (var i = 0;
-     i < const$222/*Keyword.values*/.get$length(); i++) {
+     $notnull_bool(i < const$222/*Keyword.values*/.get$length()); i++) {
       strings.$setindex(i, const$222/*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", "leg/scanner/keyword.dart", 160, 12);
   var chunk = 0;
   var chunkStart = -1;
   for (var i = offset;
-   i < offset + length; i++) {
-    if (strings.$index(i).length > start) {
+   $notnull_bool(i < offset + length); i++) {
+    if ($notnull_bool(strings.$index(i).length > start)) {
       var c = strings.$index(i).charCodeAt(start);
-      if (chunk != c) {
-        if (chunkStart != -1) {
+      if ($notnull_bool(chunk != c)) {
+        if ($notnull_bool(chunkStart != -1)) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
-  if (chunkStart != -1) {
+  if ($notnull_bool(chunkStart != -1)) {
     result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart));
   }
   else {
-    return new LeafKeywordState(strings.$index(offset));
+    $assert(length == 1, "length == 1", "leg/scanner/keyword.dart", 182, 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) {
   return this.table.$index(c - 97/*null.$a*/);
 }
 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;
-   i < foo.length; i++) {
-    if ($ne(foo.$index(i), null)) {
+   $notnull_bool(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) {
-  this.keyword = Keyword.get$keywords().$index(syntax);
+  var $0;
+  this.keyword = (($0 = Keyword.get$keywords().$index(syntax)) && $0.is$Keyword());
   // Initializers done
 }
 $inherits(LeafKeywordState, KeywordState);
 LeafKeywordState.prototype.get$keyword = function() { return this.keyword; };
 LeafKeywordState.prototype.set$keyword = function(value) { return this.keyword = value; };
 LeafKeywordState.prototype.isLeaf = function() {
   return true;
 }
 LeafKeywordState.prototype.next = function(c) {
   return null;
 }
 LeafKeywordState.prototype.toString = function() {
   return this.keyword.syntax;
 }
 // ********** Code for top level **************
 //  ********** Library tree **************
 // ********** Code for Node **************
 function Node() {}
+Node.prototype.is$Node = function(){return this;};
 Node.prototype.hashCode = function() {
   return this._hashCode;
 }
 Node.prototype.toString = function() {
   return this.unparse();
 }
 Node.prototype.unparse = function() {
   var unparser = new DebugUnparser();
   try {
     return unparser.unparse(this);
@@ skipping 23 matching lines @@
   return visitor.visitSend(this);
 }
 Send.prototype.get$isPropertyAccess = function() {
   return this.argumentsNode == null;
 }
 Send.prototype.getBeginToken = function() {
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
   var token = this.argumentsNode.getEndToken();
-  if (token != null) return token;
-  if (this.selector != null) {
+  if ($notnull_bool(token != null)) return token;
+  if ($notnull_bool(this.selector != null)) {
     return this.selector.getEndToken();
   }
   return this.receiver.getBeginToken();
 }
 // ********** Code for SetterSend **************
 function SetterSend(receiver0, selector0, assignmentOperator, argumentsNode0) {
   this.assignmentOperator = assignmentOperator;
   Send.call(this, receiver0, selector0, argumentsNode0);
   // Initializers done
 }
@@ skipping 12 matching lines @@
 NodeList.singleton$ctor = function(node) {
   NodeList.call(this, null, LinkFactory.Link$factory(node));
   // Initializers done
 }
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $inherits(NodeList, Node);
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
-  if (this.beginToken != null) return this.beginToken;
-  if (this.nodes != null) {
+  var $0;
+  if ($notnull_bool(this.beginToken != null)) return this.beginToken;
+  if ($notnull_bool(this.nodes != null)) {
     for (var link = this.nodes;
-     !link.isEmpty(); link = link.get$tail()) {
-      if (link.get$head().getBeginToken() != null) {
+     $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+      if ($notnull_bool(link.get$head().getBeginToken() != null)) {
         return link.get$head().getBeginToken();
       }
-      if (link.get$head().getEndToken() != null) {
+      if ($notnull_bool(link.get$head().getEndToken() != null)) {
         return link.get$head().getEndToken();
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
-  if (this.endToken != null) return this.endToken;
-  if (this.nodes != null) {
+  var $0;
+  if ($notnull_bool(this.endToken != null)) return this.endToken;
+  if ($notnull_bool(this.nodes != null)) {
     var link = this.nodes;
-    while (!link.get$tail().isEmpty()) link = link.get$tail();
-    if (link.get$head().getEndToken() != null) return link.get$head().getEndToken();
-    if (link.get$head().getBeginToken() != null) return link.get$head().getBeginToken();
+    while ($notnull_bool(!link.get$tail().isEmpty())) link = (($0 = link.get$tail()) && $0.is$Link$Node());
+    if ($notnull_bool(link.get$head().getEndToken() != null)) return link.get$head().getEndToken();
+    if ($notnull_bool(link.get$head().getBeginToken() != null)) return link.get$head().getBeginToken();
   }
   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 (this.elsePart == null) return this.thenPart.getEndToken();
+  if ($notnull_bool(this.elsePart == null)) return this.thenPart.getEndToken();
   return this.elsePart.getEndToken();
 }
 // ********** Code for FunctionExpression **************
 function FunctionExpression(name, parameters, body, returnType) {
   this.name = name;
   this.parameters = parameters;
   this.body = body;
   this.returnType = returnType;
   // Initializers done
 }
 $inherits(FunctionExpression, Expression);
+FunctionExpression.prototype.is$FunctionExpression = function(){return this;};
 FunctionExpression.prototype.get$name = function() { return this.name; };
 FunctionExpression.prototype.get$parameters = function() { return this.parameters; };
 FunctionExpression.prototype.get$returnType = function() { return this.returnType; };
 FunctionExpression.prototype.accept = function(visitor) {
   return visitor.visitFunctionExpression(this);
 }
 FunctionExpression.prototype.getBeginToken = function() {
   return firstBeginToken(this.returnType, this.name);
 }
 FunctionExpression.prototype.getEndToken = function() {
@@ skipping 47 matching lines @@
   return this._hashCode;
 }
 // ********** Code for LiteralInt **************
 function LiteralInt(token0, handler0) {
   Literal$int.call(this, token0, handler0);
   // Initializers done
 }
 $inherits(LiteralInt, Literal$int);
 LiteralInt.prototype.get$value = function() {
   try {
-    return Math.parseInt(this.token.get$value().toString());
+    return Math.parseInt($assert_String(this.token.get$value().toString()));
   } catch (ex) {
     ex = $toDartException(ex);
     if (!(ex instanceof BadNumberFormatException)) throw ex;
     (this.handler)(this.token, ex);
   }
 }
 LiteralInt.prototype.accept = function(visitor) {
   return visitor.visitLiteralInt(this);
 }
 LiteralInt.prototype.getBeginToken = function() {
   return null;
 }
 LiteralInt.prototype.getEndToken = function() {
   return null;
 }
 // ********** Code for LiteralDouble **************
 function LiteralDouble(token0, handler0) {
   Literal$double.call(this, token0, handler0);
   // Initializers done
 }
 $inherits(LiteralDouble, Literal$double);
 LiteralDouble.prototype.get$value = function() {
   try {
-    return Math.parseDouble(this.token.get$value().toString());
+    return Math.parseDouble($assert_String(this.token.get$value().toString()));
   } catch (ex) {
     ex = $toDartException(ex);
     if (!(ex instanceof BadNumberFormatException)) throw ex;
     (this.handler)(this.token, ex);
   }
 }
 LiteralDouble.prototype.accept = function(visitor) {
   return visitor.visitLiteralDouble(this);
 }
 // ********** Code for LiteralBool **************
@@ skipping 32 matching lines @@
 }
 LiteralString.prototype.accept = function(visitor) {
   return visitor.visitLiteralString(this);
 }
 // ********** Code for Identifier **************
 function Identifier(token) {
   this.token = token;
   // Initializers done
 }
 $inherits(Identifier, Expression);
+Identifier.prototype.is$Identifier = function(){return this;};
 Identifier.prototype.get$source = function() {
   return this.token.get$value();
 }
 Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 Identifier.prototype.getBeginToken = function() {
   return this.token;
 }
 Identifier.prototype.getEndToken = function() {
@@ skipping 93 matching lines @@
   // Initializers done
 }
 DebugUnparser.prototype.unparse = function(node) {
   this.separator = '';
   this.sb = new StringBufferImpl("");
   this.visit(node);
   return this.sb.toString();
 }
 DebugUnparser.prototype.visit = function(node, withSeparator) {
   var previous = this.separator;
-  this.separator = (withSeparator != null) ? withSeparator : this.separator;
-  if (node != null) node.accept(this);
+  this.separator = $assert_String($notnull_bool((withSeparator != null)) ? withSeparator : this.separator);
+  if ($notnull_bool(node != null)) node.accept(this);
   this.separator = previous;
 }
 DebugUnparser.prototype.visitBlock = function(node) {
   this.visit(node.statements);
 }
 DebugUnparser.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
   this.sb.add(';');
 }
 DebugUnparser.prototype.visitFunctionExpression = function(node) {
-  if (node.returnType != null) {
+  if ($notnull_bool(node.returnType != null)) {
     this.visit(node.returnType);
     this.sb.add(' ');
   }
   this.visit(node.name);
   this.visit(node.parameters, ', ');
   this.visit(node.body);
 }
 DebugUnparser.prototype.visitIdentifier = function(node) {
   node.get$source().printOn(this.sb);
 }
 DebugUnparser.prototype.visitIf = function(node) {
   node.ifToken.get$value().printOn$1(this.sb);
   this.visit(node.condition);
   this.visit(node.thenPart);
-  if (node.get$hasElsePart()) {
+  if ($notnull_bool(node.get$hasElsePart())) {
     node.elseToken.get$value().printOn$1(this.sb);
     this.visit(node.elsePart);
   }
 }
 DebugUnparser.prototype.visitLiteralBool = function(node) {
   node.token.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitLiteralDouble = function(node) {
   node.token.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitLiteralInt = function(node) {
   node.token.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitLiteralString = function(node) {
   node.token.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitNodeList = function(node) {
+  var $0;
   var first = true;
-  if (node.beginToken != null) this.sb.add(node.beginToken);
-  if (node.nodes != null) {
+  if ($notnull_bool(node.beginToken != null)) this.sb.add(node.beginToken);
+  if ($notnull_bool(node.nodes != null)) {
     var delimiter = node.delimiter;
-    if (delimiter == null) delimiter = new StringWrapper(this.separator);
+    if ($notnull_bool(delimiter == null)) delimiter = new StringWrapper(this.separator);
     var $list = node.nodes;
     for (var $i = node.nodes.iterator(); $i.hasNext(); ) {
       var element = $i.next();
-      if (!first) delimiter.printOn(this.sb);
+      if ($notnull_bool(!first)) delimiter.printOn(this.sb);
       first = false;
       this.visit(element);
     }
   }
-  if (node.endToken != null) this.sb.add(node.endToken);
+  if ($notnull_bool(node.endToken != null)) this.sb.add(node.endToken);
 }
 DebugUnparser.prototype.visitOperator = function(node) {
   this.visitIdentifier(node);
 }
 DebugUnparser.prototype.visitParameter = function(node) {
-  if (node.typeAnnotation != null) {
+  if ($notnull_bool(node.typeAnnotation != null)) {
     this.visit(node.typeAnnotation);
     this.sb.add(' ');
   }
   this.visit(node.name);
 }
 DebugUnparser.prototype.visitReturn = function(node) {
   node.beginToken.get$value().printOn$1(this.sb);
-  if (node.get$hasExpression()) {
+  if ($notnull_bool(node.get$hasExpression())) {
     this.sb.add(' ');
     this.visit(node.expression);
   }
   node.endToken.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitSend = function(node) {
-  if (node.receiver != null) {
+  if ($notnull_bool(node.receiver != null)) {
     this.visit(node.receiver);
-    if (!(node.selector instanceof Operator)) this.sb.add('.');
+    if ($notnull_bool(!(node.selector instanceof Operator))) this.sb.add('.');
   }
   this.visit(node.selector);
   this.visit(node.argumentsNode, ', ');
 }
 DebugUnparser.prototype.visitSetterSend = function(node) {
-  if (node.receiver != null) {
+  if ($notnull_bool(node.receiver != null)) {
     this.visit(node.receiver);
     this.sb.add('.');
   }
   this.visit(node.selector);
   node.assignmentOperator.get$value().printOn$1(this.sb);
   this.visit(node.argumentsNode, ', ');
 }
 DebugUnparser.prototype.visitTypeAnnotation = function(node) {
   this.visit(node.typeName);
 }
 DebugUnparser.prototype.visitVariableDefinitions = function(node) {
-  if (node.type != null) {
+  if ($notnull_bool(node.type != null)) {
     this.visit(node.type);
     this.sb.add(' ');
   }
   this.visit(node.definitions, ', ');
   this.sb.add('; ');
 }
 // ********** Code for top level **************
 function firstBeginToken(first, second) {
-  return (first != null) ? first.getBeginToken() : second.getBeginToken();
+  return $notnull_bool((first != null)) ? first.getBeginToken() : second.getBeginToken();
 }
 //  ********** Library elements **************
 // ********** Code for Element **************
 function Element(name, enclosingElement) {
   this.name = name;
   this.enclosingElement = enclosingElement;
   // Initializers done
 }
+Element.prototype.is$Element = function(){return this;};
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 // ********** Code for FunctionElement **************
 function FunctionElement(name0) {
   Element.call(this, name0);
   // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.computeType = function(compiler, types) {
-  if (this.type != null) return this.type;
+  var $0;
+  if ($notnull_bool(this.type != null)) return this.type;
   var node = this.parseNode(compiler, compiler);
   var returnType = getType(node.returnType, types);
   var parameterTypes = new LinkBuilderImplementation$Type();
   for (var link = node.parameters.nodes;
-   !link.isEmpty(); link = link.get$tail()) {
+   $notnull_bool(!link.isEmpty()); link = link.get$tail()) {
     compiler.cancel('parameters not supported.');
     var parameter = link.get$head();
     parameterTypes.addLast(getType(parameter.typeAnnotation, types));
   }
-  this.type = new FunctionType(returnType, parameterTypes.toLink());
+  this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return this.type;
 }
 // ********** Code for top level **************
 function getType(annotation, types) {
-  if (annotation == null || annotation.typeName == null) {
+  if ($notnull_bool(annotation == null || annotation.typeName == null)) {
     return types.DYNAMIC;
   }
   var name = annotation.typeName.get$source();
-  if ($eq(name, types.VOID.get$name())) {
+  if ($notnull_bool($eq(name, types.VOID.get$name()))) {
     return types.VOID;
   }
-  else if ($eq(name, types.INT.get$name())) {
+  else if ($notnull_bool($eq(name, types.INT.get$name()))) {
     return types.INT;
   }
-  else if ($eq(name, types.STRING.get$name())) {
+  else if ($notnull_bool($eq(name, types.STRING.get$name()))) {
     return types.STRING;
   }
   else {
     $throw("Unreachable");
   }
 }
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
 function SsaBuilderTask(compiler0) {
   CompilerTask.call(this, compiler0);
   // Initializers done
 }
 $inherits(SsaBuilderTask, CompilerTask);
 SsaBuilderTask.prototype.get$name = function() {
   return 'SSA builder';
 }
 SsaBuilderTask.prototype.build = function(tree) {
   var $this = this; // closure support
   return this.measure((function () {
     var function_ = tree;
     var graph = $this.compileMethod(function_.body);
-    if (false/*null.GENERATE_SSA_TRACE*/) {
+    $assert(graph.isValid(), "graph.isValid()", "leg/ssa/builder.dart", 13, 14);
+    if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
       var name0 = tree.get$name();
       HTracer.HTracer$singleton$factory().traceCompilation(name0.get$source().toString());
       HTracer.HTracer$singleton$factory().traceGraph('builder', graph);
     }
     return graph;
   })
   );
 }
 SsaBuilderTask.prototype.compileMethod = function(body) {
   var builder = new SsaBuilder(this.compiler);
   var graph = builder.build(body);
   return graph;
 }
 // ********** Code for SsaBuilder **************
 function SsaBuilder(compiler) {
   this.compiler = compiler;
   // Initializers done
 }
 SsaBuilder.prototype.build = function(body) {
   this.graph = new HGraph();
   this.block = new HBasicBlock();
   this.stack = new ListFactory$HInstruction();
   body.accept(this);
-  if (this.block.last == null || !(this.block.last instanceof HReturn)) {
+  if ($notnull_bool(this.block.last == null || !(this.block.last instanceof HReturn))) {
     this.block.add(new HGoto());
     this.graph.setSuccessors(this.block, [this.graph.exit]);
   }
   this.graph.entry.add(new HGoto());
   this.graph.setSuccessors(this.graph.entry, [this.block]);
   return this.graph;
 }
 SsaBuilder.prototype.add = function(instruction) {
   this.block.add(instruction);
 }
 SsaBuilder.prototype.push = function(instruction) {
   this.add(instruction);
   this.stack.add(instruction);
 }
 SsaBuilder.prototype.pop = function() {
   return this.stack.removeLast();
 }
 SsaBuilder.prototype.visit = function(node) {
-  if (node != null) node.accept(this);
+  if ($notnull_bool(node != null)) node.accept(this);
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   this.visit(node.statements);
-  if (!this.stack.isEmpty()) this.compiler.cancel('non-empty instruction stack');
+  if ($notnull_bool(!this.stack.isEmpty())) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
   this.pop();
 }
 SsaBuilder.prototype.visitFunctionExpression = function(node) {
   this.compiler.cancel();
 }
 SsaBuilder.prototype.visitIdentifier = function(node) {
   this.compiler.cancel();
 }
 SsaBuilder.prototype.visitIf = function(node) {
   this.compiler.cancel("ssa/builder.dart: visitIf not implemented");
 }
 SsaBuilder.prototype.visitSend = function(node) {
-  if ((node.selector instanceof Operator)) {
+  var $0;
+  if ($notnull_bool((node.selector instanceof Operator))) {
     this.visit(node.receiver);
     this.visit(node.argumentsNode);
     var right = this.pop();
     var left = this.pop();
     var op = node.selector;
-    if ($eq(const$258/*const SourceString("+")*/, op.get$source())) {
+    if ($notnull_bool($eq(const$258/*const SourceString("+")*/, op.get$source()))) {
       this.push(new HAdd([left, right]));
     }
-    else if ($eq(const$259/*const SourceString("-")*/, op.get$source())) {
+    else if ($notnull_bool($eq(const$259/*const SourceString("-")*/, op.get$source()))) {
       this.push(new HSubtract([left, right]));
     }
-    else if ($eq(const$260/*const SourceString("*")*/, op.get$source())) {
+    else if ($notnull_bool($eq(const$260/*const SourceString("*")*/, op.get$source()))) {
       this.push(new HMultiply([left, right]));
     }
-    else if ($eq(const$261/*const SourceString("/")*/, op.get$source())) {
+    else if ($notnull_bool($eq(const$261/*const SourceString("/")*/, op.get$source()))) {
       this.push(new HDivide([left, right]));
     }
-    else if ($eq(const$262/*const SourceString("~/")*/, op.get$source())) {
+    else if ($notnull_bool($eq(const$262/*const SourceString("~/")*/, op.get$source()))) {
       this.push(new HTruncatingDivide([left, right]));
     }
   }
   else {
     this.visit(node.argumentsNode);
     var arguments = [];
     for (var link = node.get$arguments();
-     !link.isEmpty(); link = link.get$tail()) {
+     $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       arguments.add(this.pop());
     }
     var selector = node.selector;
     this.push(new HInvoke(selector.get$source(), arguments));
   }
 }
 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;
-   !link.isEmpty(); link = link.get$tail()) {
-    this.visit(link.get$head());
+   $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.visitParameter = function(node) {
   this.compiler.unimplemented("SsaBuilder::visitParameter");
 }
 SsaBuilder.prototype.visitReturn = function(node) {
   this.visit(node.expression);
@@ skipping 14 matching lines @@
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(tree, graph) {
   var $this = this; // closure support
   return this.measure((function () {
     var function_ = tree;
     var name0 = function_.name;
-    if (false/*null.GENERATE_SSA_TRACE*/) {
+    if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
       HTracer.HTracer$singleton$factory().traceGraph("codegen", graph);
     }
     var code = $this.generateMethod(name0.get$source(), graph);
     return code;
   })
   );
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, graph) {
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.compiler, buffer);
   graph.number();
   codegen.visitGraph(graph);
   return ('function ' + methodName + '() {\n' + buffer + '}\n');
 }
 // ********** Code for SsaCodeGenerator **************
 function SsaCodeGenerator(compiler, buffer) {
   this.compiler = compiler;
   this.buffer = buffer;
   // Initializers done
 }
 SsaCodeGenerator.prototype.visitGraph = function(graph) {
   var $this = this; // closure support
   function visitBasicBlockAndSuccessors(block) {
+    var $0;
     $this.visit(block);
-    if (!block.successors.isEmpty()) {
-      visitBasicBlockAndSuccessors(block.successors.$index(0));
+    if ($notnull_bool(!block.successors.isEmpty())) {
+      $assert(block.successors.length == 1, "block.successors.length == 1", "leg/ssa/codegen.dart", 39, 16);
+      visitBasicBlockAndSuccessors((($0 = block.successors.$index(0)) && $0.is$HBasicBlock()));
     }
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 SsaCodeGenerator.prototype.temporary = function(instruction) {
   return ('t' + instruction.id + '');
 }
 SsaCodeGenerator.prototype.invoke = function(selector, arguments) {
+  var $0;
   this.buffer.add(("" + selector + "("));
   for (var i = 0;
-   i < arguments.length; i++) {
-    if (i != 0) this.buffer.add(', ');
-    this.use(arguments.$index(i));
+   $notnull_bool(i < arguments.length); i++) {
+    if ($notnull_bool(i != 0)) this.buffer.add(', ');
+    this.use((($0 = arguments.$index(i)) && $0.is$HInstruction()));
   }
   this.buffer.add(")");
 }
 SsaCodeGenerator.prototype.define = function(instruction) {
   this.buffer.add(('var ' + this.temporary(instruction) + ' = '));
   this.visit(instruction);
 }
 SsaCodeGenerator.prototype.use = function(argument) {
-  if (argument.canBeGeneratedAtUseSite()) {
+  if ($notnull_bool(argument.canBeGeneratedAtUseSite())) {
     this.visit(argument);
   }
   else {
     this.buffer.add(this.temporary(argument));
   }
 }
 SsaCodeGenerator.prototype.visit = function(node) {
   return node.accept(this);
 }
 SsaCodeGenerator.prototype.visitAdd = function(node) {
   this.invoke(const$266/*const SourceString('\$add')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitBasicBlock = function(node) {
   var instruction = node.first;
-  while (instruction != null) {
-    if (!instruction.canBeSkipped()) {
+  while ($notnull_bool(instruction != null)) {
+    if ($notnull_bool(!instruction.canBeSkipped())) {
       this.buffer.add('  ');
-      if (!instruction.get$usedBy().isEmpty()) {
+      if ($notnull_bool(!instruction.get$usedBy().isEmpty())) {
         this.define(instruction);
       }
       else {
         this.visit(instruction);
       }
       this.buffer.add(';\n');
     }
     instruction = instruction.next;
   }
 }
 SsaCodeGenerator.prototype.visitDivide = function(node) {
   this.invoke(const$267/*const SourceString('\$div')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitExit = function(node) {
   unreachable();
 }
 SsaCodeGenerator.prototype.visitGoto = function(node) {
   unreachable();
 }
 SsaCodeGenerator.prototype.visitInvoke = function(node) {
   this.invoke(node.selector, node.inputs);
 }
 SsaCodeGenerator.prototype.visitLiteral = function(node) {
   this.buffer.add(node.value);
 }
 SsaCodeGenerator.prototype.visitMultiply = function(node) {
   this.invoke(const$268/*const SourceString('\$mul')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitReturn = function(node) {
+  var $0;
   this.buffer.add('return ');
-  this.use(node.inputs.$index(0));
+  this.use((($0 = node.inputs.$index(0)) && $0.is$HInstruction()));
 }
 SsaCodeGenerator.prototype.visitSubtract = function(node) {
   this.invoke(const$269/*const SourceString('\$sub')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitTruncatingDivide = function(node) {
   this.invoke(const$270/*const SourceString('\$tdiv')*/, node.inputs);
 }
 // ********** 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);
     for (var i = 0;
-     i < block.successors.length; i++) {
-      visitBasicBlockAndSuccessors(block.successors.$index(i));
+     $notnull_bool(i < block.successors.length); i++) {
+      visitBasicBlockAndSuccessors((($0 = block.successors.$index(i)) && $0.is$HBasicBlock()));
     }
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 HGraphVisitor.prototype.visitPostDominatorTree = function(graph) {
   var $this = this; // closure support
   function visitBasicBlockAndSuccessors(block) {
+    var $0;
     for (var i = 0;
-     i < block.successors.length; i++) {
-      visitBasicBlockAndSuccessors(block.successors.$index(i));
+     $notnull_bool(i < block.successors.length); i++) {
+      visitBasicBlockAndSuccessors((($0 = block.successors.$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 (instruction != null) {
+  while ($notnull_bool(instruction != null)) {
     this.visitInstruction(instruction);
     instruction = instruction.next;
   }
 }
 // ********** Code for HGraph **************
 function HGraph() {
   this.entry = new HBasicBlock();
   this.exit = new HBasicBlock();
   // Initializers done
   this.exit.add(new HExit());
 }
 HGraph.prototype.number = function() {
   var basicBlockId = 0;
   function numberBasicBlockAndSuccessors(block, id) {
+    var $0;
     id = block.number(basicBlockId++, id);
     for (var i = 0;
-     i < block.successors.length; i++) {
-      id = numberBasicBlockAndSuccessors(block.successors.$index(i), id);
+     $notnull_bool(i < block.successors.length); i++) {
+      id = numberBasicBlockAndSuccessors((($0 = block.successors.$index(i)) && $0.is$HBasicBlock()), id);
     }
     return id;
   }
   numberBasicBlockAndSuccessors(this.entry, 0);
 }
 HGraph.prototype.setSuccessors = function(source, targets) {
+  $assert(((source.last instanceof HGoto) || (source.last instanceof HReturn)) && targets.length == 1, "(source.last is HGoto || source.last is HReturn) &&\n           targets.length == 1", "leg/ssa/nodes.dart", 83, 12);
+  $assert(source.successors.isEmpty(), "source.successors.isEmpty()", "leg/ssa/nodes.dart", 85, 12);
   source.successors = targets;
   for (var i = 0;
-   i < targets.length; i++) {
+   $notnull_bool(i < targets.length); i++) {
     targets.$index(i).predecessors.add(source);
   }
 }
 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 (instruction != null) {
+  while ($notnull_bool(instruction != null)) {
     instruction.accept(this);
     instruction = instruction.next;
   }
 }
 HBaseVisitor.prototype.visitInstruction = function(HInstruction0) {
 
 }
 HBaseVisitor.prototype.visitArithmetic = function(node, operation) {
   return this.visitInvoke(node);
 }
@@ skipping 28 matching lines @@
   return this.visitArithmetic(node, '~/');
 }
 // ********** Code for HBasicBlock **************
 function HBasicBlock() {
   this.first = null
   this.last = null
   this.predecessors = [];
   this.successors = const$226/*const []*/;
   // Initializers done
 }
+HBasicBlock.prototype.is$HBasicBlock = function(){return this;};
 HBasicBlock.prototype.number = function(basicBlockId, id0) {
   this.id = basicBlockId;
   var instruction = this.first;
-  while (instruction != null) {
+  while ($notnull_bool(instruction != null)) {
     instruction.id = id0++;
     instruction = instruction.next;
   }
   return id0;
 }
 HBasicBlock.prototype.accept = function(visitor) {
   return visitor.visitBasicBlock(this);
 }
 HBasicBlock.prototype.add = function(instruction) {
   this.addAfter(this.last, instruction);
 }
 HBasicBlock.prototype.addAfter = function(cursor, instruction) {
-  if (cursor == null) {
+  if ($notnull_bool(cursor == null)) {
     this.first = this.last = instruction;
   }
-  else if (cursor === this.last) {
+  else if ($notnull_bool(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) {
-  if (instruction.previous == null) {
+  $assert(instruction.isInBasicBlock(), "instruction.isInBasicBlock()", "leg/ssa/nodes.dart", 183, 12);
+  $assert(instruction.get$usedBy().isEmpty(), "instruction.usedBy.isEmpty()", "leg/ssa/nodes.dart", 184, 12);
+  if ($notnull_bool(instruction.previous == null)) {
     this.first = instruction.next;
   }
   else {
     instruction.previous.next = instruction.next;
   }
-  if (instruction.next == null) {
+  if ($notnull_bool(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 = [];
+  $assert(this.isValid(), "isValid()", "leg/ssa/nodes.dart", 208, 12);
 }
 HBasicBlock.rewriteInput = function(instruction, from, to) {
   var inputs = instruction.inputs;
   for (var i = 0;
-   i < inputs.length; i++) {
-    if (inputs.$index(i) === from) inputs.$setindex(i, to);
+   $notnull_bool(i < inputs.length); i++) {
+    if ($notnull_bool(inputs.$index(i) === from)) inputs.$setindex(i, to);
   }
 }
 HBasicBlock.prototype.isExitBlock = function() {
   return this.first === this.last && (this.first instanceof HExit);
 }
 HBasicBlock.prototype.isValid = function() {
   var validator = new HValidator();
   validator.visitBasicBlock(this);
   return validator.isValid;
 }
 // ********** Code for HInstruction **************
 function HInstruction(inputs) {
   this._usedBy = null
   this.previous = null
   this.next = null
   this._canBeGeneratedAtUseSite = false
   this.inputs = inputs;
   // Initializers done
 }
+HInstruction.prototype.is$HInstruction = function(){return this;};
 HInstruction.prototype.canBeGeneratedAtUseSite = function() {
   return this._canBeGeneratedAtUseSite;
 }
 HInstruction.prototype.setCanBeGeneratedAtUseSite = function() {
   this._canBeGeneratedAtUseSite = true;
 }
 HInstruction.prototype.canBeSkipped = function() {
   return this.canBeGeneratedAtUseSite();
 }
 HInstruction.prototype.get$usedBy = function() {
-  if (this._usedBy == null) return const$226/*const []*/;
+  if ($notnull_bool(this._usedBy == null)) return const$226/*const []*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.$eq = function(other) {
   return false;
 }
 HInstruction.prototype.hashCode = function() {
   return 0;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
+  $assert(!this.isInBasicBlock(), "!isInBasicBlock()", "leg/ssa/nodes.dart", 283, 12);
   this._usedBy = [];
   for (var i = 0;
-   i < this.inputs.length; i++) {
+   $notnull_bool(i < this.inputs.length); i++) {
     this.inputs.$index(i).get$usedBy().add(this);
   }
+  $assert(this.isValid(), "isValid()", "leg/ssa/nodes.dart", 289, 12);
 }
 HInstruction.prototype.notifyRemovedFromBlock = function() {
+  $assert(this.isInBasicBlock(), "isInBasicBlock()", "leg/ssa/nodes.dart", 293, 12);
+  $assert(this.get$usedBy().isEmpty(), "usedBy.isEmpty()", "leg/ssa/nodes.dart", 294, 12);
   for (var i = 0;
-   i < this.inputs.length; i++) {
+   $notnull_bool(i < this.inputs.length); i++) {
     var inputUsedBy = this.inputs.$index(i).get$usedBy();
     for (var j = 0;
-     j < inputUsedBy.length; j++) {
-      if (inputUsedBy.$index(j) === this) {
+     $notnull_bool(j < inputUsedBy.length); j++) {
+      if ($notnull_bool(inputUsedBy.$index(j) === this)) {
         inputUsedBy.$setindex(j, inputUsedBy.$index(inputUsedBy.length - 1));
         inputUsedBy.removeLast();
         break;
       }
     }
   }
   this._usedBy = null;
+  $assert(this.isValid(), "isValid()", "leg/ssa/nodes.dart", 308, 12);
 }
 HInstruction.prototype.isValid = function() {
   var validator = new HValidator();
   validator.visitInstruction(this);
   return validator.isValid;
 }
 // ********** Code for HInvoke **************
 function HInvoke(selector, inputs0) {
   this.selector = selector;
   HInstruction.call(this, inputs0);
@@ skipping 163 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 (instruction != null) {
+  while ($notnull_bool(instruction != null)) {
     var replacement = instruction.accept(this);
-    if (replacement !== instruction) {
-      block.addAfter(instruction, replacement);
-      block.rewrite(instruction, replacement);
+    if ($notnull_bool(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.visitArithmetic = function(node, operation) {
   function isNumber(input) {
     return (input instanceof HLiteral) && (typeof(input.get$value()) == 'number');
   }
   var inputs = node.inputs;
-  if (isNumber(inputs.$index(0)) && isNumber(inputs.$index(1))) {
+  $assert(inputs.length == 2, "inputs.length == 2", "leg/ssa/optimize.dart", 50, 12);
+  if ($notnull_bool(isNumber(inputs.$index(0)) && isNumber(inputs.$index(1)))) {
     switch (operation) {
       case '+':
 
         return new HLiteral(inputs.$index(0).get$value() + inputs.$index(1).get$value());
 
       case '-':
 
         return new HLiteral(inputs.$index(0).get$value() - inputs.$index(1).get$value());
 
       case '*':
 
         return new HLiteral(inputs.$index(0).get$value() * inputs.$index(1).get$value());
 
       case '/':
 
         {
-          if ($eq(inputs.$index(1).get$value(), 0)) return node;
+          if ($notnull_bool($eq(inputs.$index(1).get$value(), 0))) return node;
           return new HLiteral(inputs.$index(0).get$value() / inputs.$index(1).get$value());
         }
 
       case '~/':
 
         {
-          if ($eq(inputs.$index(1).get$value(), 0)) return node;
+          if ($notnull_bool($eq(inputs.$index(1).get$value(), 0))) return node;
           return new HLiteral($truncdiv(inputs.$index(0).get$value(), inputs.$index(1).get$value()));
         }
 
       default:
 
         unreachable();
 
     }
   }
   return node;
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
   return !instruction.hasSideEffects() && instruction.get$usedBy().isEmpty();
 }
 SsaDeadCodeEliminator.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaDeadCodeEliminator.prototype.visitBasicBlock = function(block) {
   var instruction = block.last;
-  while (instruction != null) {
+  while ($notnull_bool(instruction != null)) {
     var previous = instruction.previous;
-    if (SsaDeadCodeEliminator.isDeadCode(instruction)) block.remove(instruction);
-    instruction = previous;
+    if ($notnull_bool(SsaDeadCodeEliminator.isDeadCode(instruction))) block.remove(instruction);
+    instruction = (previous && previous.is$HInstruction());
   }
 }
 // ********** Code for SsaGlobalValueNumberer **************
 function SsaGlobalValueNumberer(compiler) {
   this.compiler = compiler;
   this.values = new HashMapImplementation$HInstruction$HInstruction();
   // Initializers done
 }
 $inherits(SsaGlobalValueNumberer, HGraphVisitor);
 SsaGlobalValueNumberer.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaGlobalValueNumberer.prototype.visitBasicBlock = function(block) {
   var instruction = block.first;
-  while (instruction != null) {
-    if (instruction.hasSideEffects()) {
+  while ($notnull_bool(instruction != null)) {
+    if ($notnull_bool(instruction.hasSideEffects())) {
       this.values.clear();
     }
     else {
       var other = this.values.$index(instruction);
-      if (other != null) {
+      if ($notnull_bool(other != null)) {
         block.rewrite(instruction, other);
         block.remove(instruction);
       }
       else {
         this.values.$setindex(instruction, instruction);
       }
     }
     instruction = instruction.next;
   }
 }
 // ********** 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;
-   i >= 0; i--) {
-    if (previousUnused == null) return;
-    if (inputs.$index(i).get$usedBy().length != 1) return;
-    if (inputs.$index(i) !== previousUnused) return;
+   $notnull_bool(i >= 0); i--) {
+    if ($notnull_bool(previousUnused == null)) return;
+    if ($notnull_bool(inputs.$index(i).get$usedBy().length != 1)) return;
+    if ($notnull_bool(inputs.$index(i) !== previousUnused)) return;
     inputs.$index(i).setCanBeGeneratedAtUseSite();
     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 (HTracer._singleton == null) HTracer._singleton = new HTracer._internal$ctor();
+  if ($notnull_bool(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.number();
   this.tag("cfg", (function () {
     $this.printProperty("name", name);
     $this.visitDominatorTree(graph);
   })
   );
 }
 HTracer.prototype.addPredecessors = function(block) {
-  if (block.predecessors.isEmpty()) {
+  if ($notnull_bool(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 (block.successors.isEmpty()) {
+  if ($notnull_bool(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;
-   instruction != null; instruction = instruction.next) {
+   $notnull_bool(instruction != null); instruction = instruction.next) {
     var bci = 0;
     var uses = instruction.get$usedBy().length;
     this.addIndent();
     var temporaryId = stringifier.temporaryId(instruction);
     var instructionString = 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", "leg/ssa/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");
     $this.tag("states", (function () {
       $this.tag("locals", (function () {
@@ skipping 19 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 ((typeof(value) == 'number')) {
+  if ($notnull_bool((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;
-   i < this.indent; i++) {
+   $notnull_bool(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 14 matching lines @@
   return this.visitInvoke(node);
 }
 HInstructionStringifier.prototype.visitExit = function(node) {
   return "exit";
 }
 HInstructionStringifier.prototype.visitGoto = function(node) {
   var target = this.currentBlock.successors.$index(0);
   return ("Goto (B" + target.id + ")");
 }
 HInstructionStringifier.prototype.visitInvoke = function(invoke) {
+  var $0;
   var arguments = new StringBufferImpl("");
   for (var i = 0;
-   i < invoke.inputs.length; i++) {
-    if (i != 0) arguments.add(", ");
-    arguments.add(this.temporaryId(invoke.inputs.$index(i)));
+   $notnull_bool(i < invoke.inputs.length); i++) {
+    if ($notnull_bool(i != 0)) arguments.add(", ");
+    arguments.add(this.temporaryId((($0 = invoke.inputs.$index(i)) && $0.is$HInstruction())));
   }
   return ("Invoke: " + invoke.selector + "(" + arguments + ")");
 }
 HInstructionStringifier.prototype.visitLiteral = function(literal) {
   return ("Literal " + literal.value + "");
 }
 HInstructionStringifier.prototype.visitMultiply = function(node) {
   return this.visitInvoke(node);
 }
 HInstructionStringifier.prototype.visitReturn = function(node) {
-  return ("Return " + this.temporaryId(node.inputs.$index(0)) + "");
+  var $0;
+  return ("Return " + this.temporaryId((($0 = node.inputs.$index(0)) && $0.is$HInstruction())) + "");
 }
 HInstructionStringifier.prototype.visitSubtract = function(node) {
   return this.visitInvoke(node);
 }
 HInstructionStringifier.prototype.visitTruncatingDivide = function(node) {
   return this.visitInvoke(node);
 }
 // ********** Code for HValidator **************
 function HValidator() {
   this.isValid = true
   HInstructionVisitor.call(this);
   // Initializers done
 }
 $inherits(HValidator, HInstructionVisitor);
 HValidator.prototype.visitGraph = function(graph0) {
   this.graph = graph0;
   this.visitDominatorTree(graph0);
 }
 HValidator.prototype.visitBasicBlock = function(block) {
-  if (!this.isValid) return;
-  if (block.first == null || block.last == null) this.isValid = false;
-  if (!(block.last instanceof HGoto) && !(block.last instanceof HReturn) && !(block.last instanceof HExit)) {
+  if ($notnull_bool(!this.isValid)) return;
+  if ($notnull_bool(block.first == null || block.last == null)) this.isValid = false;
+  if ($notnull_bool(!(block.last instanceof HGoto) && !(block.last instanceof HReturn) && !(block.last instanceof HExit))) {
     this.isValid = false;
   }
-  if ((block.last instanceof HGoto) && block.successors.length != 1) this.isValid = false;
-  if ((block.last instanceof HReturn) && (block.successors.length != 1 || !block.successors.$index(0).isExitBlock())) {
+  if ($notnull_bool((block.last instanceof HGoto) && block.successors.length != 1)) this.isValid = false;
+  if ($notnull_bool((block.last instanceof HReturn) && (block.successors.length != 1 || !block.successors.$index(0).isExitBlock()))) {
     this.isValid = false;
   }
-  if ((block.last instanceof HExit) && !block.successors.isEmpty()) this.isValid = false;
-  if (block.successors.isEmpty() && (block.first !== block.last || !(block.last instanceof HExit))) {
+  if ($notnull_bool((block.last instanceof HExit) && !block.successors.isEmpty())) this.isValid = false;
+  if ($notnull_bool(block.successors.isEmpty() && (block.first !== block.last || !(block.last instanceof HExit)))) {
     this.isValid = false;
   }
-  if (!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;
-   i < instructions.length; i++) {
-    if (instructions.$index(i) === instruction) result++;
+   $notnull_bool(i < instructions.length); i++) {
+    if ($notnull_bool(instructions.$index(i) === instruction)) result++;
   }
   return result;
 }
 HValidator.everyInstruction = function(instructions, f) {
   var copy = ListFactory.ListFactory$from$factory(instructions);
   for (var i = 0;
-   i < copy.length; i++) {
+   $notnull_bool(i < copy.length); i++) {
     var current = copy.$index(i);
-    if (current == null) continue;
+    if ($notnull_bool(current == null)) continue;
     var count = 1;
     for (var j = i + 1;
-     j < copy.length; j++) {
-      if (copy.$index(j) === current) {
+     $notnull_bool(j < copy.length); j++) {
+      if ($notnull_bool(copy.$index(j) === current)) {
         copy.$setindex(j);
         count++;
       }
     }
-    if (!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(instruction0) {
     var inBasicBlock = instruction0.isInBasicBlock();
     return HValidator.everyInstruction(instruction0.inputs, (function (input, count) {
-      if (inBasicBlock) {
-        return HValidator.countInstruction(input.get$usedBy(), instruction0) == count;
+      if ($notnull_bool(inBasicBlock)) {
+        return HValidator.countInstruction(input.get$usedBy(), (instruction0 && instruction0.is$HInstruction())) == count;
       }
       else {
-        return HValidator.countInstruction(input.get$usedBy(), instruction0) == 0;
+        return HValidator.countInstruction(input.get$usedBy(), (instruction0 && instruction0.is$HInstruction())) == 0;
       }
     })
     );
   }
   function hasCorrectUses(instruction0) {
-    if (!instruction0.isInBasicBlock()) return true;
+    if ($notnull_bool(!instruction0.isInBasicBlock())) return true;
     return HValidator.everyInstruction(instruction0.get$usedBy(), (function (use, count) {
-      return HValidator.countInstruction(use.inputs, instruction0) == count;
+      return HValidator.countInstruction(use.inputs, (instruction0 && instruction0.is$HInstruction())) == count;
     })
     );
   }
-  this.isValid = this.isValid && hasCorrectInputs(instruction) && hasCorrectUses(instruction);
+  this.isValid = $assert_bool(this.isValid && hasCorrectInputs(instruction) && hasCorrectUses(instruction));
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldCompiler **************
 function WorldCompiler(world, script0) {
   this.world = world;
   Compiler.call(this, script0);
   // Initializers done
 }
 $inherits(WorldCompiler, Compiler);
 WorldCompiler.prototype.log = function(message) {
-  if (options.showInfo) {
+  if ($notnull_bool(options.showInfo)) {
     this.world.info(('[leg] ' + message + ''));
   }
 }
 WorldCompiler.prototype.run = function() {
   var success = Compiler.prototype.run.call(this);
-  if (success) {
+  if ($notnull_bool(success)) {
     var code = this.getGeneratedCode();
-    this.world.legCode = code;
+    this.world.legCode = $assert_String(code);
     this.world.jsBytesWritten = code.length;
     var $list = this.tasks;
     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 (begin == null || end == null) {
+  if ($notnull_bool(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) {
-  this.world.warning(('' + message + '.'), this.spanFromNode(node));
+  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$2/*Compiler.MAIN*/]);
+  this.worklist = DoubleLinkedQueue.DoubleLinkedQueue$from$factory([const$3/*Compiler.MAIN*/]);
   this.scanner = new ScannerTask(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.resolver, this.checker, this.builder, this.optimizer, this.generator];
 }
 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 (false/*null.GENERATE_SSA_TRACE*/) {
+  if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
     print("------------------");
     print(HTracer.HTracer$singleton$factory());
     print("------------------");
   }
   this.log('compilation succeeded');
   return true;
 }
 Compiler.prototype.runCompiler = function() {
   this.scanner.scan(this.script);
-  while (!this.worklist.isEmpty()) {
+  while ($notnull_bool(!this.worklist.isEmpty())) {
     var name = this.worklist.removeLast();
     var element = this.universe.find(name);
-    if (element == null) this.cancel(('Could not find ' + name + ''));
+    if ($notnull_bool(element == null)) this.cancel(('Could not find ' + name + ''));
     var tree = element.parseNode(this, this);
     var elements = this.resolver.resolve(tree);
     this.checker.check(tree, elements);
     var graph = this.builder.build(tree);
     this.optimizer.optimize(graph);
     var code = this.generator.generate(tree, graph);
     this.universe.addGeneratedCode(element, code);
   }
 }
 Compiler.prototype.getGeneratedCode = function() {
   var buffer = new StringBufferImpl("");
   buffer.add("var print = (typeof console == 'object')\n    ? function(obj) { console.log(obj); }\n    : function(obj) { write(obj); write('\\n'); };\n"/*null.PRINT_SUPPORT*/);
   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 $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 = this.universe.generatedCode.getValues();
   for (var i = codeBlocks.length - 1;
-   i >= 0; i--) {
+   $notnull_bool(i >= 0); i--) {
     buffer.add(codeBlocks.$index(i));
   }
   buffer.add('main();\n');
   return buffer.toString();
 }
 // ********** Code for CompilerTask **************
 function CompilerTask(compiler) {
   this.compiler = compiler;
   this.watch = new StopWatchImplementation();
   // Initializers done
@@ skipping 10 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 (this.reason != null) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
+  return $notnull_bool((this.reason != null)) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
 }
 // ********** Code for ResolverTask **************
 function ResolverTask(compiler0) {
   CompilerTask.call(this, compiler0);
   // Initializers done
 }
 $inherits(ResolverTask, CompilerTask);
 ResolverTask.prototype.get$name = function() {
   return 'Resolver';
 }
@@ skipping 10 matching lines @@
 function ResolverVisitor(compiler0) {
   this.compiler = compiler0;
   this.mapping = new HashMapImplementation$Node$Element();
   this.context = new Scope(new TopScope(compiler0.universe));
   // Initializers done
 }
 ResolverVisitor.prototype.fail = function(node) {
   this.compiler.cancel(('cannot resolve ' + node + ''));
 }
 ResolverVisitor.prototype.visit = function(node) {
-  if (node == null) return null;
+  if ($notnull_bool(node == null)) return null;
   var element = node.accept(this);
-  if (element != null) {
+  if ($notnull_bool(element != null)) {
     this.mapping.$setindex(node, element);
   }
   return element;
 }
 ResolverVisitor.prototype.visitIn = function(node, scope) {
   this.context = scope;
   var element = this.visit(node);
   this.context = this.context.parent;
   return element;
 }
 ResolverVisitor.prototype.visitBlock = function(node) {
   this.visitIn(node.statements, new Scope(this.context));
 }
 ResolverVisitor.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitFunctionExpression = function(node) {
-  if (!node.parameters.nodes.isEmpty()) this.fail(node);
+  if ($notnull_bool(!node.parameters.nodes.isEmpty())) this.fail(node);
   var enclosingElement = this.visit(node.name);
   this.visitIn(node.body, new Scope.enclosing$ctor(this.context, enclosingElement));
   return enclosingElement;
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   var element = this.context.lookup(node.get$source());
-  if (element == null) this.fail(node);
+  if ($notnull_bool(element == null)) this.fail(node);
   return 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 name = node.selector.get$source();
-  if ($eq(name, const$248/*const SourceString('print')*/) || $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($eq(name, const$248/*const SourceString('print')*/) || $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.visit(node.selector);
-    if (target == null) {
+    target = (($0 = this.visit(node.selector)) && $0.is$Element());
+    if ($notnull_bool(target == null)) {
       this.fail(node);
     }
     else {
       this.compiler.worklist.add(node.selector.get$source());
     }
   }
   this.visit(node.argumentsNode);
   return target;
 }
 ResolverVisitor.prototype.visitSetterSend = function(node) {
   this.compiler.unimplemented('ResolverVisitor::visitSetterSend');
 }
 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;
-   !link.isEmpty(); link = link.get$tail()) {
-    this.visit(link.get$head());
+   $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);
 }
 ResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
   return null;
 }
 ResolverVisitor.prototype.visitTypeAnnotation = function(node) {
 
 }
 ResolverVisitor.prototype.visitVariableDefinitions = function(node) {
   var visitor = new VariableDefinitionsVisitor(node, this);
   visitor.visit(node.definitions);
 }
 ResolverVisitor.prototype.setElement = function(node, element) {
   this.mapping.$setindex(node, element);
   this.context.add(element);
 }
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
   this.definitions = definitions;
   this.resolver = resolver;
   // Initializers done
 }
 VariableDefinitionsVisitor.prototype.visitSend = function(node) {
+  var $0;
+  $assert(node.get$arguments().get$tail().isEmpty(), "node.arguments.tail.isEmpty()", "leg/resolver.dart", 157, 12);
   var selector = node.selector;
   var name = selector.get$source();
-  this.resolver.visit(node.get$arguments().get$head());
+  $assert($eq(name, const$244/*const SourceString('=')*/), "name == const SourceString('=')", "leg/resolver.dart", 160, 12);
+  this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   this.visit(node.receiver);
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   var variableElement = new Element(node.get$source(), this.resolver.context.enclosingElement);
   this.resolver.setElement(node, variableElement);
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
+  var $0;
   for (var link = node.nodes;
-   !link.isEmpty(); link = link.get$tail()) {
-    this.visit(link.get$head());
+   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+    this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 // ********** Code for Scope **************
 function Scope(parent0) {
   Scope.enclosing$ctor.call(this, parent0, parent0.enclosingElement);
   // Initializers done
 }
 Scope.top$ctor = function() {
   this.parent = null;
   this.elements = const$247/*const {}*/;
   this.enclosingElement = null;
   // Initializers done
 }
 Scope.top$ctor.prototype = Scope.prototype;
 Scope.enclosing$ctor = function(parent, enclosingElement) {
   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 element = this.elements.$index(name);
-  if (element != null) return element;
+  if ($notnull_bool(element != null)) return element;
   return this.parent.lookup(name);
 }
 Scope.prototype.add = function(element) {
   this.elements.$setindex(element.name, element);
 }
 // ********** Code for TopScope **************
 function TopScope(universe) {
   this.universe = universe;
   Scope.top$ctor.call(this);
   // Initializers done
@@ skipping 10 matching lines @@
   CompilerTask.call(this, compiler0);
   // Initializers done
 }
 $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;
-     !link.isEmpty(); link = link.get$tail()) {
-      $this.compiler.universe.define(link.get$head());
+     $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 Listener(this.compiler);
   var parser = new Parser(listener);
   parser.parseUnit(tokens);
   return listener.topLevelElements;
@@ skipping 27 matching lines @@
 function CompilerError() {}
 CompilerError.NOT_ASSIGNABLE = function(t, s) {
   return ('' + t + ' is not assignable to ' + s + '');
 }
 // ********** Code for SimpleType **************
 function SimpleType(name, element) {
   this.name = name;
   this.element = element;
   // Initializers done
 }
+SimpleType.prototype.is$Type = function(){return this;};
 SimpleType.prototype.get$name = function() { return this.name; };
 SimpleType.prototype.get$element = function() { return this.element; };
 SimpleType.prototype.toString = function() {
   return this.name.toString();
 }
 // ********** Code for FunctionType **************
 function FunctionType(returnType, parameterTypes) {
   this.returnType = returnType;
   this.parameterTypes = parameterTypes;
   // Initializers done
 }
+FunctionType.prototype.is$Type = function(){return this;};
 FunctionType.prototype.get$returnType = function() { return this.returnType; };
 FunctionType.prototype.toString = function() {
+  var $0;
   var sb = new StringBufferImpl("");
   var first = true;
   sb.add('(');
   for (var link = this.parameterTypes;
-   !link.isEmpty(); link = link.get$tail()) {
-    if (!first) sb.add(', ');
+   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Type())) {
+    if ($notnull_bool(!first)) sb.add(', ');
     first = false;
     sb.add(link.get$head());
   }
   sb.add((') -> ' + this.returnType + ''));
   return sb.toString();
 }
 // ********** Code for Types **************
 function Types() {
   this.VOID = new SimpleType(const$254, new Element(const$254/*const SourceString('void')*/));
   this.INT = new SimpleType(const$255, new Element(const$255/*const SourceString('int')*/));
@@ skipping 36 matching lines @@
   this.visit(node.body);
   this.expectedReturnType = previous;
   return functionType;
 }
 TypeCheckerVisitor.prototype.visitIdentifier = function(node) {
   this.fail(node);
 }
 TypeCheckerVisitor.prototype.visitIf = function(node) {
   this.visit(node.condition);
   this.visit(node.thenPart);
-  if (node.get$hasElsePart()) this.visit(node.elsePart);
+  if ($notnull_bool(node.get$hasElsePart())) this.visit(node.elsePart);
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
+  var $0;
   var target = this.elements.$index(node);
-  if (target != null) {
+  if ($notnull_bool(target != null)) {
     var funType = target.computeType(this.compiler, this.types);
     var formals = funType.parameterTypes;
     var arguments = node.get$arguments();
-    while ((!formals.isEmpty()) && (!arguments.isEmpty())) {
+    while ($notnull_bool((!formals.isEmpty()) && (!arguments.isEmpty()))) {
       this.compiler.cancel('parameters not supported.');
-      var argumentType = this.visit(arguments.get$head());
-      if (!this.types.isAssignable(formals.get$head(), argumentType)) {
-        var warning = CompilerError.NOT_ASSIGNABLE(argumentType, formals.get$head());
+      var argumentType = this.visit((($0 = arguments.get$head()) && $0.is$Node()));
+      if ($notnull_bool(!this.types.isAssignable((($0 = formals.get$head()) && $0.is$Type()), (argumentType && argumentType.is$Type())))) {
+        var warning = CompilerError.NOT_ASSIGNABLE((argumentType && argumentType.is$Type()), (($0 = formals.get$head()) && $0.is$Type()));
         this.compiler.reportWarning(node, warning);
       }
-      formals = formals.get$tail();
-      arguments = arguments.get$tail();
+      formals = (($0 = formals.get$tail()) && $0.is$Link$Type());
+      arguments = (($0 = arguments.get$tail()) && $0.is$Link$Node());
     }
-    if (!formals.isEmpty()) {
+    if ($notnull_bool(!formals.isEmpty())) {
       this.compiler.reportWarning(node, 'missing argument');
     }
-    if (!arguments.isEmpty()) {
+    if ($notnull_bool(!arguments.isEmpty())) {
       this.compiler.reportWarning(node, 'additional arguments');
     }
     return funType.returnType;
   }
   else {
     var selector = node.selector;
     var name = selector.get$source();
-    if ($eq(name, const$248/*const SourceString('print')*/) || $eq(name, const$249/*const SourceString('+')*/)) {
+    if ($notnull_bool($eq(name, const$248/*const SourceString('print')*/) || $eq(name, const$249/*const SourceString('+')*/))) {
       return this.types.DYNAMIC;
     }
     this.compiler.cancel(('unresolved send ' + name + '.'));
   }
 }
 TypeCheckerVisitor.prototype.visitSetterSend = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitLiteralInt = function(node) {
   return this.types.INT;
 }
 TypeCheckerVisitor.prototype.visitLiteralDouble = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitLiteralBool = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitLiteralString = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
+  var $0;
   for (var link = node.nodes;
-   !link.isEmpty(); link = link.get$tail()) {
-    this.visit(link.get$head());
+   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+    this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitParameter = function(node) {
   return null;
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expressionType = this.visit(node.expression);
-  if (!this.types.isAssignable(this.expectedReturnType, expressionType)) {
+  if ($notnull_bool(!this.types.isAssignable(this.expectedReturnType, expressionType))) {
     var error = CompilerError.NOT_ASSIGNABLE(this.expectedReturnType, expressionType);
     this.compiler.reportWarning(node, error);
   }
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitTypeAnnotation = function(node) {
-  if (node.typeName != null && $ne(node.typeName.get$source(), const$254/*const SourceString('void')*/)) {
+  if ($notnull_bool(node.typeName != null && $ne(node.typeName.get$source(), const$254/*const SourceString('void')*/))) {
     this.compiler.cancel(('unsupported type ' + node.typeName + ''));
   }
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   return this.types.VOID;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
-  this.scope = new Element(const$1/*const SourceString('global scope')*/);
+  this.scope = new Element(const$2/*const SourceString('global scope')*/);
   // Initializers done
 }
 Universe.prototype.find = function(name) {
   return this.elements.$index(name);
 }
 Universe.prototype.define = function(element) {
+  $assert(this.elements.$index(element.name) == null, "elements[element.name] == null", "leg/universe.dart", 19, 12);
   this.elements.$setindex(element.name, element);
 }
 Universe.prototype.addGeneratedCode = function(element, code) {
   this.generatedCode.$setindex(element, code);
 }
 // ********** Code for top level **************
 function unreachable() {
   $throw(const$265/*const Exception("Internal Error (Leg): UNREACHABLE")*/);
 }
 function compile(world) {
   var file = world.readFile(options.dartScript);
   var script = new leg_Script(file);
   var compiler = new WorldCompiler(world, script);
   return compiler.run();
 }
 //  ********** Library lang **************
 // ********** Code for CodeWriter **************
 function CodeWriter() {
   this._indentation = 0
   this._pendingIndent = false
   this.writeComments = true
   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;
-   i < this._indentation; i++) {
+   $notnull_bool(i < this._indentation); i++) {
     this._buf.add('  '/*CodeWriter.INDENTATION*/);
   }
 }
 CodeWriter.prototype.comment = function(text0) {
-  if (this.writeComments) {
+  if ($notnull_bool(this.writeComments)) {
     this.writeln(text0);
   }
 }
 CodeWriter.prototype.write = function(text0) {
-  if (text0.length == 0) return;
-  if (this._pendingIndent) this._indent();
-  if (text0.indexOf('\n', 0) != -1) {
+  if ($notnull_bool(text0.length == 0)) return;
+  if ($notnull_bool(this._pendingIndent)) this._indent();
+  if ($notnull_bool(text0.indexOf('\n', 0) != -1)) {
     var lines = text0.split('\n');
     for (var i = 0;
-     i < lines.length - 1; i++) {
-      this.writeln(lines.$index(i));
+     $notnull_bool(i < lines.length - 1); i++) {
+      this.writeln($assert_String(lines.$index(i)));
     }
-    this.write(lines.$index(lines.length - 1));
+    this.write($assert_String(lines.$index(lines.length - 1)));
   }
   else {
     this._buf.add(text0);
   }
 }
 CodeWriter.prototype.writeln = function(text0) {
-  if (text0 != null) {
+  if ($notnull_bool(text0 != null)) {
     this.write(text0);
   }
-  if (!text0.endsWith('\n')) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
+  if ($notnull_bool(!text0.endsWith('\n'))) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
   this._pendingIndent = true;
 }
 CodeWriter.prototype.enterBlock = function(text0) {
   this.writeln(text0);
   this._indentation++;
 }
 CodeWriter.prototype.exitBlock = function(text0) {
   this._indentation--;
   this.writeln(text0);
 }
 CodeWriter.prototype.nextBlock = function(text0) {
   this._indentation--;
   this.writeln(text0);
   this._indentation++;
 }
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
   this.main = main;
   this.writer = writer;
   this.globals = $map([]);
   // Initializers done
 }
 WorldGenerator.prototype.run = function() {
   var metaGen = new MethodGenerator(this.main, null);
-  var mainCall = this.main.invoke(metaGen, null, null, Arguments.get$EMPTY(), false);
+  var mainCall = this.main.invoke((metaGen && metaGen.is$MethodGenerator()), null, null, Arguments.get$EMPTY(), false);
   this.main.declaringType.markUsed();
   world.corelib.types.$index('BadNumberFormatException').markUsed();
   world.get$coreimpl().types.$index('MatchImplementation').markUsed();
   world.get$coreimpl().types.$index('NumImplementation').markUsed();
   world.get$coreimpl().types.$index('StringImplementation').markUsed();
   this.writeTypes(world.get$coreimpl());
   this.writeTypes(world.corelib);
   var matchConstructor = world.get$coreimpl().types.$index('MatchImplementation').getConstructor('');
-  this.genMethod(matchConstructor);
+  this.genMethod((matchConstructor && matchConstructor.is$Member()));
   matchConstructor.generator.writeDefinition(this.writer, null);
   this.writeTypes(this.main.declaringType.get$library());
   this._writeDynamicStubs(world.functionType);
   this._writeGlobals();
   this.writer.writeln(('' + mainCall.code + ';'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
-  if (!this.globals.containsKey(fullname)) {
+  if ($notnull_bool(!this.globals.containsKey(fullname))) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
   return this.globals.$index(fullname);
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var code = exp.canonicalCode;
-  if (!this.globals.containsKey(code)) {
+  if ($notnull_bool(!this.globals.containsKey(code))) {
     this.globals.$setindex(code, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
   return this.globals.$index(code);
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
-  if (lib.isWritten) return;
+  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;
-   i < lib.sources.length; i++) {
+   $notnull_bool(i < lib.sources.length); i++) {
     lib.sources.$index(i).orderInLibrary = i;
   }
   this.writer.comment(('//  ********** Library ' + lib.name + ' **************'));
   var $list = lib.natives;
   for (var $i = 0;$i < $list.length; $i++) {
     var file = $list.$index($i);
     var filename = basename(file.filename);
     this.writer.comment(('//  ********** Natives ' + filename + ' **************'));
     this.writer.writeln(file.get$text());
   }
   lib.topType.markUsed();
   var $list = this._orderValues(lib.types);
   for (var $i = 0;$i < $list.length; $i++) {
     var type = $list.$index($i);
-    if (type.get$isUsed() && type.get$isClass()) {
-      this.writeType(type);
-      if (type.get$isGeneric()) {
+    if ($notnull_bool(type.get$isUsed() && type.get$isClass())) {
+      this.writeType((type && type.is$lang_Type()));
+      if ($notnull_bool(type.get$isGeneric())) {
         var $list0 = this._orderValues(type._concreteTypes);
         for (var $i0 = 0;$i0 < $list0.length; $i0++) {
           var ct = $list0.$index($i0);
-          this.writeType(ct);
+          this.writeType((ct && ct.is$lang_Type()));
         }
       }
     }
+    if ($notnull_bool(type.typeCheckCode != null)) {
+      this.writer.writeln(type.typeCheckCode);
+    }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
-  if (!meth.isGenerated && meth.declaringType.get$isClass() && $ne(meth.get$definition(), null) && !meth.get$isAbstract()) {
+  if ($notnull_bool(!meth.isGenerated && meth.declaringType.get$isClass() && $ne(meth.get$definition(), null) && !meth.get$isAbstract())) {
     new MethodGenerator(meth, enclosingMethod).run();
   }
 }
 WorldGenerator.prototype._maybeIsTest = function(onType, checkType) {
-  if (!checkType.isTested) return;
+  if ($notnull_bool(!checkType.isTested)) return;
   var value = 'false';
-  if (onType.isSubtypeOf(checkType)) {
+  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) {
-  if (type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
+  var $0;
+  if ($notnull_bool(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 = type.get$jsname() != null ? type.get$jsname() : 'top level';
+  var typeName = $notnull_bool(type.get$jsname() != null) ? type.get$jsname() : 'top level';
   this.writer.comment(('// ********** Code for ' + typeName + ' **************'));
-  if (type.get$isNativeType() && !type.get$isTop()) {
+  if ($notnull_bool(type.get$isNativeType() && !type.get$isTop())) {
     var nativeName = type.get$definition().nativeType;
-    if ($eq(nativeName, '')) {
+    if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
-    else if (type.get$jsname() != nativeName) {
+    else if ($notnull_bool(type.get$jsname() != nativeName)) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
-  if (type.get$isTop()) {
+  if ($notnull_bool(type.get$isTop())) {
   }
-  else if (type.constructors.get$length() == 0) {
-    if (!type.get$isNativeType()) {
+  else if ($notnull_bool(type.constructors.get$length() == 0)) {
+    if ($notnull_bool(!type.get$isNativeType())) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
     var standardConstructor = type.constructors.$index('');
-    if (standardConstructor == null || standardConstructor.generator == null) {
-      if (!type.get$isNativeType()) {
+    if ($notnull_bool(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.constructors.getValues();
     for (var $i = type.constructors.getValues().iterator(); $i.hasNext(); ) {
       var c = $i.next();
-      if ($ne(c.generator, null) && $ne(c, standardConstructor)) {
+      if ($notnull_bool($ne(c.generator, null) && $ne(c, standardConstructor))) {
         c.generator.writeDefinition(this.writer, null);
       }
     }
   }
-  if (!type.get$isTop()) {
-    if ((type instanceof ConcreteType)) {
+  if ($notnull_bool(!type.get$isTop())) {
+    if ($notnull_bool((type instanceof ConcreteType))) {
       this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
     }
-    else if (!type.get$isNativeType()) {
-      if (type.get$parent() != null && !type.get$parent().get$isObject()) {
+    else if ($notnull_bool(!type.get$isNativeType())) {
+      if ($notnull_bool(type.get$parent() != null && !type.get$parent().get$isObject())) {
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
-  if (!(type instanceof ConcreteType)) {
+  if ($notnull_bool(!(type instanceof ConcreteType))) {
     this._maybeIsTest(type, type);
   }
-  if (type.get$genericType()._concreteTypes != null) {
+  if ($notnull_bool(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);
+      this._maybeIsTest(type, (ct && ct.is$lang_Type()));
     }
   }
-  if (type.get$interfaces() != null) {
+  if ($notnull_bool(type.get$interfaces() != null)) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
-    while (!worklist.isEmpty()) {
+    while ($notnull_bool(!worklist.isEmpty())) {
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
-      if (interface_.get$genericType()._concreteTypes != null) {
+      if ($notnull_bool(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);
+          this._maybeIsTest(type, (ct && ct.is$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
       for (var $i = 0;$i < $list.length; $i++) {
         var other = $list.$index($i);
-        if (!seen.contains(other)) {
+        if ($notnull_bool(!seen.contains(other))) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
   type.factories.forEach$1(this.get$_writeMethod());
-  var $list = this._orderValues(type.members);
+  var $list = this._orderValues((($0 = type.members) && $0.is$Map()));
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
-    if ((member instanceof FieldMember)) {
-      this._writeField(member);
+    if ($notnull_bool((member instanceof FieldMember))) {
+      this._writeField((member && member.is$FieldMember()));
     }
-    if ((member instanceof PropertyMember)) {
-      this._writeProperty(member);
+    if ($notnull_bool((member instanceof PropertyMember))) {
+      this._writeProperty((member && member.is$PropertyMember()));
     }
-    if (member.get$isMethod()) {
-      this._writeMethod(member);
+    if ($notnull_bool(member.get$isMethod())) {
+      this._writeMethod((member && member.is$Member()));
     }
   }
   this._writeDynamicStubs(type);
 }
 WorldGenerator.prototype._writeDynamicStubs = function(type) {
-  if (type.varStubs != null) {
+  if ($notnull_bool(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 (field.isFinal) return;
+  if ($notnull_bool(field.isFinal)) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
-  if (this.globals.containsKey(fullname)) {
+  if ($notnull_bool(this.globals.containsKey(fullname))) {
     var value = this.globals.$index(fullname);
-    if (field.declaringType.get$isTop() && !field.isNative) {
+    if ($notnull_bool(field.declaringType.get$isTop() && !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 (field.declaringType.get$isTop() && !field.isNative && field.value == null) {
+  if ($notnull_bool(field.declaringType.get$isTop() && !field.isNative && field.value == null)) {
     this.writer.writeln(('var ' + field.get$jsname() + ';'));
   }
-  if (field._providePropertySyntax) {
+  if ($notnull_bool(field._providePropertySyntax)) {
     this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.get\$' + field.get$jsname() + ' = ') + ('function() { return this.' + field.get$jsname() + '; };'));
-    if (!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 (property.getter != null) this._writeMethod(property.getter);
-  if (property.setter != null) this._writeMethod(property.setter);
-  if (property._provideFieldSyntax) {
+  if ($notnull_bool(property.getter != null)) this._writeMethod(property.getter);
+  if ($notnull_bool(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 (property.getter != null) {
+    if ($notnull_bool(property.getter != null)) {
       this.writer.writeln(('get: ' + property.declaringType.get$jsname() + '.prototype.' + property.getter.get$jsname() + ','));
     }
-    if (property.setter != null) {
+    if ($notnull_bool(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 (method.generator != null) {
+  if ($notnull_bool(method.generator != null)) {
     method.generator.writeDefinition(this.writer, null);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return WorldGenerator.prototype._writeMethod.bind(this);
 }
 WorldGenerator.prototype._writeGlobals = function() {
+  var $0;
   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 (global.field != null) {
+    if ($notnull_bool(global.field != null)) {
       this._writeStaticField(global.field);
     }
     else {
       this.writer.writeln(('var ' + global.get$name() + ' = ' + global.exp.code + ';'));
     }
   }
 }
 WorldGenerator.prototype._orderValues = function(map0) {
   var values = map0.getValues();
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
-  if (x.get$span() != null && y.get$span() != null) {
+  if ($notnull_bool(x.get$span() != null && y.get$span() != null)) {
     var spans = x.get$span().compareTo(y.get$span());
-    if (spans != 0) return spans;
+    if ($notnull_bool(spans != 0)) return spans;
   }
-  if (x.get$span() == null) return 1;
-  if (y.get$span() == null) return -1;
+  if ($notnull_bool(x.get$span() == null)) return 1;
+  if ($notnull_bool(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;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember('\$setindex');
-  this.genMethod(m.members.$index(0));
+  this.genMethod((($0 = m.members.$index(0)) && $0.is$Member()));
   var c = factType.getConstructor('');
-  this.genMethod(c);
+  this.genMethod((c && c.is$Member()));
   return factType;
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
   // Initializers done
-  if (this.get$isMethodScope()) {
+  if ($notnull_bool(this.get$isMethodScope())) {
     this._closedOver = new HashSetImplementation$String();
   }
   else {
-    this.reentrant = this.reentrant || this.parent.reentrant;
+    this.reentrant = $assert_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
   return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
 }
 BlockScope.prototype.get$methodScope = function() {
   var s = this;
-  while (!s.get$isMethodScope()) s = s.get$parent();
+  while ($notnull_bool(!s.get$isMethodScope())) s = s.get$parent();
   return s;
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   for (var s = this.parent;
-   $ne(s, null); s = s.get$parent()) {
+   $notnull_bool($ne(s, null)); s = s.get$parent()) {
     ret = s._vars.$index(name);
-    if ($ne(ret, null)) {
-      if ($ne(s.enclosingMethod, this.enclosingMethod)) {
+    if ($notnull_bool($ne(ret, null))) {
+      if ($notnull_bool($ne(s.enclosingMethod, this.enclosingMethod))) {
         s.get$methodScope()._closedOver.add(ret.code);
-        if (this.enclosingMethod.captures != null && s.reentrant) {
+        if ($notnull_bool(this.enclosingMethod.captures != null && s.reentrant)) {
           this.enclosingMethod.captures.add(ret.code);
         }
       }
       return ret;
     }
   }
 }
 BlockScope.prototype._isDefinedInParent = function(name) {
-  if (this.get$isMethodScope() && this._closedOver.contains(name)) return true;
+  if ($notnull_bool(this.get$isMethodScope() && this._closedOver.contains(name))) return true;
   for (var s = this.parent;
-   $ne(s, null); s = s.get$parent()) {
-    if (s._vars.containsKey(name)) return true;
-    if (s.get$isMethodScope() && s._closedOver.contains(name)) return true;
+   $notnull_bool($ne(s, null)); s = s.get$parent()) {
+    if ($notnull_bool(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 (type.resolveMember(name) != null) return true;
-  if (type.get$library().lookup(name, null) != null) return true;
+  if ($notnull_bool(type.resolveMember(name) != null)) return true;
+  if ($notnull_bool(type.get$library().lookup(name, null) != null)) return true;
   return false;
 }
 BlockScope.prototype.create = function(name, type, location) {
   var jsName = world.toJsIdentifier(name);
-  if (this._vars.containsKey(name)) {
-    if (location != null) {
+  if ($notnull_bool(this._vars.containsKey(name))) {
+    if ($notnull_bool(location != null)) {
       world.error(('duplicate name "' + name + '"'), location.span);
     }
     else {
       world.internalError(('conflict with temporary name "' + name + '"'));
     }
   }
   var index = 0;
-  while (this._isDefinedInParent(jsName)) {
+  while ($notnull_bool(this._isDefinedInParent($assert_String(jsName)))) {
     jsName = ('' + name + '' + index++ + '');
   }
   var ret = new Value(type, jsName, false, false, false);
   this._vars.$setindex(name, ret);
   return ret;
 }
 BlockScope.prototype.declare = function(id) {
   var type = this.enclosingMethod.method.resolveType(id.type, false);
-  return this.create(id.name.name, type, id);
+  return this.create(id.name.name, (type && type.is$lang_Type()), id);
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
-  while (scope.rethrow == null && $ne(scope.get$parent(), null)) {
+  while ($notnull_bool(scope.rethrow == null && $ne(scope.get$parent(), null))) {
     scope = scope.get$parent();
   }
   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 (this.enclosingMethod != null) {
+  if ($notnull_bool(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 (this.enclosingMethod != null && this.method.name != '') {
-    this._scope.create(this.method.name, this.method.get$functionType(), this.method.get$definition());
+  if ($notnull_bool(this.enclosingMethod != null && this.method.name != '')) {
+    this._scope.create(this.method.name, this.method.get$functionType(), (($0 = this.method.get$definition()) && $0.is$lang_Node()));
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
+MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.findMembers = function(name) {
   return this.method.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.getTemp = function(value) {
-  return value.needsTemp ? this.forceTemp(value) : value;
+  return $notnull_bool(value.needsTemp) ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
-  if (this._freeTemps.length > 0) {
-    name = this._freeTemps.removeLast();
+  if ($notnull_bool(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, false, false, false);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
-  if ($eq(tmp, v)) {
+  if ($notnull_bool($eq(tmp, v))) {
     return v;
   }
   else {
     return new Value(v.type, ('(' + tmp.code + ' = ' + v.code + ')'), false, true, false);
   }
 }
 MethodGenerator.prototype.freeTemp = function(value) {
-  if (this._usedTemps.remove(value.code)) {
+  if ($notnull_bool(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 (this.method.isGenerated) return;
+  if ($notnull_bool(this.method.isGenerated)) return;
   this.method.isGenerated = true;
   this.method.generator = this;
-  if ((this.method.get$definition().body instanceof NativeStatement)) {
-    if (this.method.get$definition().body.body == null) {
+  if ($notnull_bool((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(this.method.get$definition().body.body);
+      this.writer.write($assert_String(this.method.get$definition().body.body));
     }
   }
   else {
     this.writeBody();
   }
 }
 MethodGenerator.prototype.writeDefinition = function(defWriter, lambda) {
   var paramCode = this._paramCode;
   var names = null;
-  if (this.captures != null && this.captures.get$length() > 0) {
+  if ($notnull_bool(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);
+    paramCode = ListFactory.ListFactory$from$factory((names && names.is$Iterable()));
     paramCode.addAll(this._paramCode);
   }
   var _params = ('(' + Strings.join(this._paramCode, ", ") + ')');
-  var params = ('(' + Strings.join(paramCode, ", ") + ')');
-  if (this.method.declaringType.get$isTop() && !this.get$isClosure()) {
+  var params = ('(' + Strings.join((paramCode && paramCode.is$List$String()), ", ") + ')');
+  if ($notnull_bool(this.method.declaringType.get$isTop() && !this.get$isClosure())) {
     defWriter.enterBlock(('function ' + this.method.get$jsname() + '' + params + ' {'));
   }
-  else if (this.get$isClosure()) {
-    if (this.method.name == '') {
+  else if ($notnull_bool(this.get$isClosure())) {
+    if ($notnull_bool(this.method.name == '')) {
       defWriter.enterBlock(('(function ' + params + ' {'));
     }
-    else if ($ne(names, null)) {
-      if (lambda == null) {
+    else if ($notnull_bool($ne(names, null))) {
+      if ($notnull_bool(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 (this.method.get$isConstructor()) {
-    if (this.method.get$constructorName() == '') {
+  else if ($notnull_bool(this.method.get$isConstructor())) {
+    if ($notnull_bool(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 (this.method.get$isFactory()) {
+  else if ($notnull_bool(this.method.get$isFactory())) {
     defWriter.enterBlock(('' + this.method.get$generatedFactoryName() + ' = function' + _params + ' {'));
   }
-  else if (this.method.get$isStatic()) {
+  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 (this.needsThis) {
+  if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
-  if (this._usedTemps.get$length() > 0 || this._freeTemps.length > 0) {
+  if ($notnull_bool(this._usedTemps.get$length() > 0 || this._freeTemps.length > 0)) {
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 651, 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 ($ne(names, null)) {
-    defWriter.exitBlock(('}).bind(null, ' + Strings.join(names, ", ") + ')'));
+  if ($notnull_bool($ne(names, null))) {
+    defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
   }
-  else if (this.get$isClosure() && this.method.name == '') {
+  else if ($notnull_bool(this.get$isClosure() && this.method.name == '')) {
     defWriter.exitBlock('})');
   }
   else {
     defWriter.exitBlock('}');
   }
-  if (this.method.get$isConstructor() && this.method.get$constructorName() != '') {
+  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 ((this.method instanceof MethodMember) && this.method._providePropertySyntax) {
+  if ($notnull_bool((this.method instanceof MethodMember) && this.method._providePropertySyntax)) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.get\$' + this.method.get$jsname() + ' = function() {'));
     defWriter.writeln(('return ' + this.method.declaringType.get$jsname() + '.prototype.' + this.method.get$jsname() + '.bind(this);'));
     defWriter.exitBlock('}');
-    if (this.method._provideFieldSyntax) {
+    if ($notnull_bool(this.method._provideFieldSyntax)) {
       world.internalError('bound method accessed with field syntax');
     }
   }
 }
 MethodGenerator.prototype._provideOptionalParamInfo = function(defWriter) {
-  if ((this.method instanceof MethodMember) && this.method._provideOptionalParamInfo) {
+  if ($notnull_bool((this.method instanceof MethodMember) && this.method._provideOptionalParamInfo)) {
     var optNames = [];
     var optValues = [];
     this.method.genParameterValues();
     var $list = this.method.get$parameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var param = $list.$index($i);
-      if (param.get$isOptional()) {
+      if ($notnull_bool(param.get$isOptional())) {
         optNames.add(param.get$name());
         optValues.add(MethodGenerator._escapeString(param.get$value().code));
       }
     }
-    if (optNames.length > 0) {
+    if ($notnull_bool(optNames.length > 0)) {
       var start = '';
-      if (this.method.get$isStatic()) {
-        if (!this.method.declaringType.get$isTop()) {
+      if ($notnull_bool(this.method.get$isStatic())) {
+        if ($notnull_bool(!this.method.declaringType.get$isTop())) {
           start = this.method.declaringType.get$jsname() + '.';
         }
       }
       else {
         start = this.method.declaringType.get$jsname() + '.prototype.';
       }
       optNames.addAll(optValues);
-      var optional = "['" + Strings.join(optNames, "', '") + "']";
+      var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
       defWriter.writeln(('' + start + '' + this.method.get$jsname() + '.\$optional = ' + optional + ''));
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
+  var $0;
   var initializers = null;
   var initializedFields = null;
-  if (this.method.get$isConstructor()) {
+  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 ((f instanceof FieldMember) && !f.get$isStatic()) {
+      if ($notnull_bool((f instanceof FieldMember) && !f.get$isStatic())) {
         var cv = f.computeValue();
-        if ($ne(cv, null)) {
+        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 ($ne(initializers, null) && p.get$name().startsWith('this.')) {
+    if ($notnull_bool($ne(initializers, null) && p.get$name().startsWith('this.'))) {
       var name = p.get$name().substring(5);
       var field = this.method.declaringType.getMember(name);
-      if (field == null) {
+      if ($notnull_bool(field == null)) {
         world.error('bad this parameter - no matching field', p.get$definition().get$span());
       }
-      if (!field.get$isField()) {
+      if ($notnull_bool(!field.get$isField())) {
         world.error(('"' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
       var paramValue = new Value(field.get$returnType(), name, false, false, false);
       this._paramCode.add(paramValue.code);
       initializers.add(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
       initializedFields.add(name);
     }
     else {
-      var paramValue = this._scope.create(p.get$name(), p.type, p.get$definition());
+      var paramValue = this._scope.create($assert_String(p.get$name()), (($0 = p.type) && $0.is$lang_Type()), (($0 = p.get$definition()) && $0.is$lang_Node()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
-  if (body == null && !this.method.get$isConstructor()) {
+  if ($notnull_bool(body == null && !this.method.get$isConstructor())) {
     world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
   }
-  if ($ne(initializers, null)) {
+  if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator(); $i.hasNext(); ) {
       var i = $i.next();
-      this.writer.writeln(i);
+      this.writer.writeln($assert_String(i));
     }
     var declaredInitializers = this.method.get$definition().initializers;
-    if (declaredInitializers != null) {
+    if ($notnull_bool(declaredInitializers != null)) {
       var initializerCall = null;
       for (var $i = 0;$i < declaredInitializers.length; $i++) {
         var init = declaredInitializers.$index($i);
-        if ((init instanceof CallExpression)) {
-          if ($ne(initializerCall, null)) {
+        if ($notnull_bool((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 ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0) {
+        else if ($notnull_bool((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0)) {
           var left = init.x;
-          if (!((left instanceof DotExpression) && (left.self instanceof ThisExpression) || (left instanceof VarExpression))) {
+          if ($notnull_bool(!((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_$4(this, left.get$name().get$name(), left.get$name(), this.visitValue(init.y));
           this.writer.writeln(('' + assign.code + ';'));
         }
         else {
           world.error('invalid initializer', init.get$span());
         }
       }
-      if ($ne(initializerCall, null)) {
-        var target = this._writeInitializerCall(initializerCall);
-        if (!target.isSuper) {
-          if (initializers.length > 0) {
+      if ($notnull_bool($ne(initializerCall, null))) {
+        var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
+        if ($notnull_bool(!target.isSuper)) {
+          if ($notnull_bool(initializers.length > 0)) {
             var $list = this.method.get$parameters();
             for (var $i = 0;$i < $list.length; $i++) {
               var p = $list.$index($i);
-              if (p.get$name().startsWith('this.')) {
+              if ($notnull_bool(p.get$name().startsWith('this.'))) {
                 world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
                 break;
               }
             }
           }
-          if (declaredInitializers.length > 1) {
-            var init = $eq(declaredInitializers.$index(0), initializerCall) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
+          if ($notnull_bool(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 ($ne(initializedFields, null)) {
+  if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.members.getKeys();
     for (var $i = this.method.declaringType.members.getKeys().iterator(); $i.hasNext(); ) {
       var name = $i.next();
       var member = this.method.declaringType.members.$index(name);
-      if ((member instanceof FieldMember) && member.isFinal && !member.get$isStatic() && !initializedFields.contains(name)) {
+      if ($notnull_bool((member instanceof FieldMember) && member.isFinal && !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);
+  this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
-  if ((targetExp instanceof DotExpression)) {
+  if ($notnull_bool((targetExp instanceof DotExpression))) {
     var dot = targetExp;
     targetExp = dot.self;
     contructorName = dot.name.name;
   }
   var target = null;
-  if ((targetExp instanceof SuperExpression)) {
-    target = this._makeSuperValue(targetExp);
+  if ($notnull_bool((targetExp instanceof SuperExpression))) {
+    target = this._makeSuperValue((targetExp && targetExp.is$lang_Node()));
   }
-  else if ((targetExp instanceof ThisExpression)) {
-    target = this._makeThisValue(targetExp);
+  else if ($notnull_bool((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 ($ne(other, null)) {
-    if ($eq(other, this.method)) {
+  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);
+  world.gen.genMethod((m && m.is$Member()));
   var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
-  if ($ne(target.type, world.objectType)) {
+  if ($notnull_bool($ne(target.type, world.objectType))) {
     this.writer.writeln(('' + value.code + ';'));
   }
   return target;
 }
 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 (arg.label != null) {
+    if ($notnull_bool(arg.label != null)) {
       seenLabel = true;
     }
-    else if (seenLabel) {
+    else if ($notnull_bool(seenLabel)) {
       world.error('bare argument can not follow named arguments', arg.get$span());
     }
-    args.add(this.visitValue(arg.get$value()));
+    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 ((body instanceof BlockStatement)) {
+  var $0;
+  if ($notnull_bool((body instanceof BlockStatement))) {
     var $list = body.body;
     for (var $i = body.body.iterator(); $i.hasNext(); ) {
       var stmt = $i.next();
       stmt.visit(this);
     }
   }
   else {
-    if (body != null) body.visit(this);
+    if ($notnull_bool(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, this);
+  world.gen.genMethod((meth && meth.is$Member()), this);
   return meth;
 }
 MethodGenerator.prototype.visitBool = function(node) {
-  return this.visitTypedValue(node, world.boolType);
+  return this.visitValue(node).convertToNonNullBool(this, node);
 }
 MethodGenerator.prototype.visitValue = function(node) {
-  if (node == null) return null;
+  if ($notnull_bool(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 ((node instanceof PostfixExpression)) {
-    var value = this.visitPostfixExpression(node, true);
+  if ($notnull_bool((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 $0;
   var parser = new lang_Parser(node.span.file, false, node.span.start);
-  this.visitStatementsInBlock(parser.block());
+  this.visitStatementsInBlock((($0 = parser.block()) && $0.is$lang_Statement()));
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
+  var $0;
   var isFinal = false;
-  if (node.modifiers != null && node.modifiers.$index(0).kind == 96/*TokenKind.FINAL*/) {
+  if ($notnull_bool(node.modifiers != null && 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;
-   i < node.names.length; i++) {
+   $notnull_bool(i < node.names.length); i++) {
     var thisType = type;
-    if (i > 0) {
+    if ($notnull_bool(i > 0)) {
       this.writer.write(', ');
     }
     var name = node.names.$index(i).get$name();
-    var value = this.visitValue(node.values.$index(i));
-    if (isFinal) {
-      if (value == null) {
+    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 (thisType.get$isVar()) thisType = value.type;
+        if ($notnull_bool(thisType.get$isVar())) thisType = value.type;
       }
     }
-    var val = this._scope.create(name, thisType, node.names.$index(i));
-    if (value == null) {
+    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), (($0 = node.names.$index(i)) && $0.is$lang_Node()));
+    if ($notnull_bool(value == null)) {
       this.writer.write(('' + val.code + ''));
     }
     else {
       this.writer.write(('' + val.code + ' = ' + value.code + ''));
     }
   }
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
+  var $0;
   var name = world.toJsIdentifier(node.name.name);
-  var meth = this._makeLambdaMethod(name, node);
-  var funcValue = this._scope.create(name, meth.get$functionType(), this.method.get$definition());
+  var meth = this._makeLambdaMethod($assert_String(name), node);
+  var funcValue = this._scope.create($assert_String(name), meth.get$functionType(), (($0 = this.method.get$definition()) && $0.is$lang_Node()));
   meth.generator.writeDefinition(this.writer, null);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
-  if (node.value == null) {
+  if ($notnull_bool(node.value == null)) {
     this.writer.writeln('return;');
   }
   else {
-    if (this.method.get$isConstructor()) {
+    if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
     }
     this.writer.writeln(('return ' + this.visitValue(node.value).code + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitThrowStatement = function(node) {
-  if (node.value != null) {
+  if ($notnull_bool(node.value != null)) {
     var value = this.visitValue(node.value);
     value.invoke$4(this, 'toString', node, Arguments.get$EMPTY());
     this.writer.writeln(('\$throw(' + value.code + ');'));
   }
   else {
     var rethrow = this._scope.getRethrow();
-    if (rethrow == null) {
+    if ($notnull_bool(rethrow == null)) {
       world.error('rethrow outside of catch', node.span);
     }
     else {
       this.writer.writeln(('throw ' + rethrow.code + ';'));
     }
   }
   return true;
 }
 MethodGenerator.prototype.visitAssertStatement = function(node) {
+  var $0;
   var test = this.visitValue(node.test);
-  if (options.enableAsserts) {
+  if ($notnull_bool(options.enableAsserts)) {
     var err = world.corelib.types.$index('AssertError');
-    world.gen.genMethod(err.getConstructor(''));
-    world.gen.genMethod(err.members.$index('toString'));
+    world.gen.genMethod((($0 = err.getConstructor('')) && $0.is$Member()));
+    world.gen.genMethod((($0 = err.members.$index('toString')) && $0.is$Member()));
     var span = node.test.span;
     var line = span.file.getLine(span.start);
-    var column = span.file.getColumn(line, span.start);
+    var column = span.file.getColumn($assert_num(line), span.start);
     this.writer.writeln(('\$assert(' + test.code + ', "' + MethodGenerator._escapeString(span.get$text()) + '",') + (' "' + span.file.filename + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
   }
   return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
-  if (node.label == null) {
+  if ($notnull_bool(node.label == null)) {
     this.writer.writeln('break;');
   }
   else {
     this.writer.writeln(('break ' + node.label.name + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitContinueStatement = function(node) {
-  if (node.label == null) {
+  if ($notnull_bool(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 (node.falseBranch != null) {
+  if ($notnull_bool(node.falseBranch != null)) {
     this.writer.write('else ');
-    if (node.falseBranch.visit(this) && exit1) {
+    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 (node.init != null) node.init.visit(this);
+  if ($notnull_bool(node.init != null)) node.init.visit(this);
   else this.writer.write(';');
-  if (node.test != null) {
+  if ($notnull_bool(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);
-    if (needsComma) this.writer.write(', ');
-    var sv = this.visitVoid(s);
+    if ($notnull_bool(needsComma)) this.writer.write(', ');
+    var sv = this.visitVoid((s && s.is$lang_Expression()));
     this.writer.write(sv.code);
     needsComma = true;
   }
   this.writer.write(') ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
+  var $0;
   var itemType = this.method.resolveType(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
-  var item = this._scope.create(itemName, itemType, node.item.name);
+  var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$lang_Type()), node.item.name);
   var listVar = list;
-  if (list.needsTemp) {
-    listVar = this._scope.create('\$list', list.type, null);
+  if ($notnull_bool(list.needsTemp)) {
+    listVar = this._scope.create('\$list', (($0 = list.type) && $0.is$lang_Type()), null);
     this.writer.writeln(('var ' + listVar.code + ' = ' + list.code + ';'));
   }
-  if (list.type.get$isList()) {
+  if ($notnull_bool(list.type.get$isList())) {
     var tmpi = this._scope.create('\$i', world.numType, null);
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = 0;') + ('' + tmpi.code + ' < ' + listVar.code + '.length; ' + tmpi.code + '++) {'));
     var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(('var ' + item.code + ' = ' + value.code + ';'));
   }
   else {
     this._pushBlock(false);
     var c = world.get$coreimpl().types.$index('ListIterator').getConstructor('');
     c.invoke$4(this, node, null, new Arguments(null, [new Value(null, 'l', false, true, false)]));
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
-    var tmpi = this._scope.create('\$i', iterator.type, null);
+    var tmpi = this._scope.create('\$i', (($0 = iterator.type) && $0.is$lang_Type()), null);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
     this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex) {
-  var types = const$392/*const [
+  var $0;
+  var types = const$393/*const [
         'NullPointerException', 'ObjectNotClosureException',
         'NoSuchMethodException', 'StackOverflowException']*/;
   for (var $i = types.iterator(); $i.hasNext(); ) {
     var name = $i.next();
     world.corelib.types.$index(name).markUsed();
   }
   this.writer.writeln(('' + ex + ' = \$toDartException(' + ex + ');'));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
+  var $0;
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
-  if (node.catches.length == 1) {
+  if ($notnull_bool(node.catches.length == 1)) {
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
-    var ex = this._scope.declare(catch_.get$exception());
-    this._scope.rethrow = ex;
+    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 (catch_.trace != null) {
+    if ($notnull_bool(catch_.trace != null)) {
       var trace = this._scope.declare(catch_.trace);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
     }
     this._genToDartException(ex.code);
-    if (!ex.type.get$isVar()) {
-      var test = ex.instanceOf(this, ex.type, catch_.get$exception().get$span(), false, true);
+    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(node.catches.$index(0).body);
+    this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$lang_Statement()));
     this._popBlock();
   }
-  else if (node.catches.length > 0) {
+  else if ($notnull_bool(node.catches.length > 0)) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', world.varType, null);
-    this._scope.rethrow = ex;
+    this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
     var trace = null;
-    if (node.catches.some((function (c) {
+    if ($notnull_bool(node.catches.some((function (c) {
       return c.trace != null;
     })
-    )) {
+    ))) {
       trace = this._scope.create('\$trace', world.varType, null);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
     }
     this._genToDartException(ex.code);
     var needsRethrow = true;
     for (var i = 0;
-     i < node.catches.length; i++) {
+     $notnull_bool(i < node.catches.length); i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
-      var tmp = this._scope.declare(catch_.get$exception());
-      if (!tmp.type.get$isVar()) {
-        var test = ex.instanceOf(this, tmp.type, catch_.get$exception().get$span(), true, true);
-        if (i == 0) {
+      var tmp = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
+      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)) {
           this.writer.enterBlock(('if (' + test.code + ') {'));
         }
         else {
           this.writer.nextBlock(('} else if (' + test.code + ') {'));
         }
       }
-      else if (i > 0) {
+      else if ($notnull_bool(i > 0)) {
         this.writer.nextBlock('} else {');
       }
       this.writer.writeln(('var ' + tmp.code + ' = ' + ex.code + ';'));
-      if (catch_.trace != null) {
+      if ($notnull_bool(catch_.trace != null)) {
         var tmptrace = this._scope.declare(catch_.trace);
         this.writer.writeln(('var ' + tmptrace.code + ' = ' + trace.code + ';'));
       }
-      this.visitStatementsInBlock(catch_.body);
+      this.visitStatementsInBlock((($0 = catch_.body) && $0.is$lang_Statement()));
       this._popBlock();
-      if (tmp.type.get$isVar()) {
-        if (i + 1 < node.catches.length) {
-          world.warning('Unreachable catch clause', node.catches.$index(i + 1));
+      if ($notnull_bool(tmp.type.get$isVar())) {
+        if ($notnull_bool(i + 1 < node.catches.length)) {
+          world.warning('Unreachable catch clause', (($0 = node.catches.$index(i + 1)) && $0.is$SourceSpan()));
         }
-        if (i > 0) {
+        if ($notnull_bool(i > 0)) {
           this.writer.exitBlock('}');
         }
         needsRethrow = false;
         break;
       }
     }
-    if (needsRethrow) {
+    if ($notnull_bool(needsRethrow)) {
       this.writer.nextBlock('} else {');
       this.writer.writeln(('throw ' + ex.code + ';'));
       this.writer.exitBlock('}');
     }
     this._popBlock();
   }
-  if (node.finallyBlock != null) {
+  if ($notnull_bool(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 (case_.label != null) {
+    if ($notnull_bool(case_.label != null)) {
       world.error('unimplemented: labeled case statement', case_.get$span());
     }
     this._pushBlock(false);
     for (var i = 0;
-     i < case_.cases.length; i++) {
+     $notnull_bool(i < case_.cases.length); i++) {
       var expr = case_.cases.$index(i);
-      if (expr == null) {
-        if (i < case_.cases.length - 1) {
+      if ($notnull_bool(expr == null)) {
+        if ($notnull_bool(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);
+        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 ($ne(case_, node.cases.$index(node.cases.length - 1)) && !caseExits) {
+    if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1)) && !caseExits)) {
       var span = case_.statements.$index(case_.statements.length - 1).get$span();
       this.writer.writeln('\$throw(new FallThroughError());');
     }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
   for (var i = 0;
-   i < statementList.length; i++) {
+   $notnull_bool(i < statementList.length); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit(this);
-    if ($ne(stmt, statementList.$index(statementList.length - 1)) && exits) {
+    if ($notnull_bool($ne(stmt, statementList.$index(statementList.length - 1)) && exits)) {
       world.warning('unreachable code', statementList.$index(i + 1).get$span());
     }
   }
   return 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 exits;
 }
 MethodGenerator.prototype.visitLabeledStatement = function(node) {
   this.writer.writeln(('' + node.name.name + ':'));
   node.body.visit(this);
   return false;
 }
 MethodGenerator.prototype.visitExpressionStatement = function(node) {
-  if ((node.body instanceof VarExpression) || (node.body instanceof ThisExpression)) {
+  if ($notnull_bool((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 (this.method.get$isStatic()) {
+  if ($notnull_bool(this.method.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 (parentType == null) {
+  if ($notnull_bool(parentType == null)) {
     world.error('no super class', node.span);
   }
   return new Value(parentType, 'this', true, true, false);
 }
 MethodGenerator.prototype._getOutermostMethod = function() {
   var result = this;
-  while (result.enclosingMethod != null) {
+  while ($notnull_bool(result.enclosingMethod != null)) {
     result = result.enclosingMethod;
   }
   return result;
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
-  if (this.enclosingMethod != null) {
+  if ($notnull_bool(this.enclosingMethod != null)) {
     var outermostMethod = this._getOutermostMethod();
     outermostMethod._checkNonStatic(node);
     outermostMethod.needsThis = true;
     return new Value(outermostMethod.method.declaringType, '\$this', false, true, false);
   }
   else {
     this._checkNonStatic(node);
     return new Value(this.method.declaringType, 'this', false, true, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = '';
-  if (node.func.name != null) {
+  if ($notnull_bool(node.func.name != null)) {
     name = world.toJsIdentifier(node.func.name.name);
   }
-  var meth = this._makeLambdaMethod(name, node.func);
+  var meth = this._makeLambdaMethod($assert_String(name), node.func);
   var w = new CodeWriter();
-  meth.generator.writeDefinition(w, node);
+  meth.generator.writeDefinition((w && w.is$CodeWriter()), node);
   return new Value(meth.get$functionType(), w.get$text(), false, true, false);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
   var target;
   var position = node.target;
   var name = '\$call';
-  if ((node.target instanceof DotExpression)) {
+  if ($notnull_bool((node.target instanceof DotExpression))) {
     target = node.target.self.visit(this);
     name = node.target.get$name().get$name();
     position = node.target.get$name();
   }
-  else if ((node.target instanceof VarExpression)) {
+  else if ($notnull_bool((node.target instanceof VarExpression))) {
     name = node.target.get$name().get$name();
     var meth = this.method.declaringType.resolveMember(name);
-    if ($ne(meth, null)) {
+    if ($notnull_bool($ne(meth, null))) {
       target = this._makeThisOrType();
       return meth.invoke$4(this, node.target, target, this._makeArgs(node.arguments));
     }
-    meth = this.method.declaringType.get$library().lookup(name, node.target.span);
-    if ($ne(meth, null)) {
+    meth = this.method.declaringType.get$library().lookup($assert_String(name), node.target.span);
+    if ($notnull_bool($ne(meth, null))) {
       return meth.invoke$4(this, node.target, null, this._makeArgs(node.arguments));
     }
     name = '\$call';
     target = node.target.visit(this);
   }
   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 kind = node.op.kind;
-  if (kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/) {
+  if ($notnull_bool(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 (x.get$isConst() && y.get$isConst()) {
-      var value = (kind == 35/*TokenKind.AND*/) ? x.get$actualValue() && y.get$actualValue() : x.get$actualValue() || y.get$actualValue();
+    if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
+      var value = $notnull_bool((kind == 35/*TokenKind.AND*/)) ? x.get$actualValue() && y.get$actualValue() : x.get$actualValue() || y.get$actualValue();
       return EvaluatedValue.EvaluatedValue$factory(x.type, value, ('' + value + ''), node.span);
     }
     return new Value(null, code, false, true, false);
   }
-  else if (kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/) {
+  else if ($notnull_bool(kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
-    if (x.get$isConst() && y.get$isConst()) {
-      var value = kind == 50/*TokenKind.EQ_STRICT*/ ? $eq(x.get$actualValue(), y.get$actualValue()) : $ne(x.get$actualValue(), y.get$actualValue());
+    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);
     }
-    if (x.code == 'null' || y.code == 'null') {
+    if ($notnull_bool(x.code == 'null' || y.code == 'null')) {
       var op = node.op.toString().substring(0, 2);
       return new Value(null, ('' + x.code + ' ' + op + ' ' + y.code + ''), false, true, false);
     }
     else {
       return new Value(null, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), false, true, false);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
-  if (assignKind == -1) {
+  if ($notnull_bool(assignKind == -1)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var name = TokenKind.binaryMethodName(node.op.kind);
-    if (node.op.kind == 49/*TokenKind.NE*/) {
+    if ($notnull_bool(node.op.kind == 49/*TokenKind.NE*/)) {
       name = '\$ne';
     }
-    if (name == null) {
+    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 (captureOriginal == null) {
+  if ($notnull_bool(captureOriginal == null)) {
     captureOriginal = (function (x) {
       return x;
     })
     ;
   }
-  if ((xn instanceof VarExpression)) {
-    return this._visitVarAssign(kind, xn, yn, position, captureOriginal);
+  if ($notnull_bool((xn instanceof VarExpression))) {
+    return this._visitVarAssign(kind, (xn && xn.is$VarExpression()), yn, position, captureOriginal);
   }
-  else if ((xn instanceof IndexExpression)) {
-    return this._visitIndexAssign(kind, xn, yn, position, captureOriginal);
+  else if ($notnull_bool((xn instanceof IndexExpression))) {
+    return this._visitIndexAssign(kind, (xn && xn.is$IndexExpression()), yn, position, captureOriginal);
   }
-  else if ((xn instanceof DotExpression)) {
-    return this._visitDotAssign(kind, xn, yn, position, captureOriginal);
+  else if ($notnull_bool((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 x = this._scope.lookup(xn.name.name);
   var y = this.visitValue(yn);
-  if (x == null) {
+  if ($notnull_bool(x == null)) {
     var members = this.method.declaringType.resolveMember(xn.name.name);
-    if ($ne(members, null)) {
+    if ($notnull_bool($ne(members, null))) {
       x = this._makeThisOrType();
     }
     else {
       var member = this.method.declaringType.get$library().lookup(xn.name.name, xn.name.span);
-      if (member == null) {
+      if ($notnull_bool(member == null)) {
         world.warning(('can not resolve ' + xn.name.name + ''), xn.span);
         return this._makeMissingValue(xn.name.name);
       }
       members = new MemberSet(member);
     }
-    if (!members.get$treatAsField() || members.get$containsMethods()) {
-      if (kind != 0) {
+    if ($notnull_bool(!members.get$treatAsField() || members.get$containsMethods())) {
+      if ($notnull_bool(kind != 0)) {
         var right = members.get_$3(this, position, x);
-        right = captureOriginal(right);
+        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);
     }
     x = members.get_$3(this, position, x);
   }
-  y = y.convertTo(this, x.type, yn, false);
-  if (kind == 0) {
-    x = captureOriginal(x);
+  y = y.convertTo(this, (($0 = x.type) && $0.is$lang_Type()), yn, false);
+  if ($notnull_bool(kind == 0)) {
+    x = captureOriginal((x && x.is$Value()));
     return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), false, true, false);
   }
-  else if (x.type.get$isNum() && y.type.get$isNum() && (kind != 46/*TokenKind.TRUNCDIV*/)) {
-    x = captureOriginal(x);
+  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 + ''), false, true, false);
   }
   else {
     var right = x;
-    right = captureOriginal(right);
+    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 + ''), false, true, false);
   }
 }
 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 (kind != 0) {
-    tmptarget = this.getTemp(target);
-    tmpindex = this.getTemp(index);
-    var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [this.assignTemp(tmpindex, index)]));
-    right = captureOriginal(right);
+  if ($notnull_bool(kind != 0)) {
+    tmptarget = this.getTemp((target && target.is$Value()));
+    tmpindex = this.getTemp((index && index.is$Value()));
+    var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [this.assignTemp((tmpindex && tmpindex.is$Value()), (index && index.is$Value()))]));
+    right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
-  var ret = this.assignTemp(tmptarget, target).invoke(this, '\$setindex', position, new Arguments(null, [index, y]), false);
-  if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
-  if ($ne(tmpindex, index)) this.freeTemp(tmpindex);
+  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 (kind != 0) {
-    tmptarget = this.getTemp(target);
+  if ($notnull_bool(kind != 0)) {
+    tmptarget = this.getTemp((target && target.is$Value()));
     var right = tmptarget.get_$3(this, xn.name.name, xn.name);
-    right = captureOriginal(right);
+    right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
-  var ret = this.assignTemp(tmptarget, target).set_(this, xn.name.name, xn.name, y, false);
-  if ($ne(tmptarget, target)) this.freeTemp(tmptarget);
+  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 value = this.visitValue(node.self);
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
-      if (value.type.get$isNum()) {
+      if ($notnull_bool(value.type.get$isNum())) {
         return new Value(value.type, ('' + node.op + '' + value.code + ''), false, true, false);
       }
       else {
-        var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
+        var kind = ($notnull_bool(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(kind, node.self, operand, node, to$call$1(null));
+        return this._visitAssign($assert_num(kind), node.self, (operand && operand.is$lang_Expression()), node, to$call$1(null));
       }
 
     case 19/*TokenKind.NOT*/:
 
-      if (value.type.get$isBool() && value.get$isConst()) {
+      if ($notnull_bool(value.type.get$isBool() && value.get$isConst())) {
         var newVal = !value.get$actualValue();
         return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
       }
       else {
         return new Value(world.boolType, ('!' + value.code + ''), false, true, false);
       }
 
     case 42/*TokenKind.ADD*/:
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
-      if (value.type.get$isNum()) {
-        if (value.get$isConst()) {
-          if (node.op.kind == 42/*TokenKind.ADD*/) {
+      if ($notnull_bool(value.type.get$isNum())) {
+        if ($notnull_bool(value.get$isConst())) {
+          if ($notnull_bool(node.op.kind == 42/*TokenKind.ADD*/)) {
             return value;
           }
-          else if (node.op.kind == 43/*TokenKind.SUB*/) {
+          else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) {
             var newVal = $negate(value.get$actualValue());
             return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
           }
           else {
             var newVal = (~value.get$actualValue().toInt()).toDouble();
             return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
           }
         }
         return new Value(value.type, ('' + node.op + '' + value.code + ''), false, true, false);
       }
       else {
         var name;
-        if (node.op.kind == 18/*TokenKind.BIT_NOT*/) name = '\$bit_not';
-        else if (node.op.kind == 43/*TokenKind.SUB*/) name = '\$negate';
+        if ($notnull_bool(node.op.kind == 18/*TokenKind.BIT_NOT*/)) name = '\$bit_not';
+        else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) name = '\$negate';
         else world.internalError(('unimplemented: unary ' + node.op + ' on var'), node.span);
         return new Value(world.varType, ('' + name + '(' + value.code + ')'), false, true, false);
       }
 
     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 (value.type.get$isNum()) {
+  if ($notnull_bool(value.type.get$isNum())) {
     return new Value(value.type, ('' + value.code + '' + node.op + ''), false, true, false);
   }
-  var kind = (16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
+  var kind = $notnull_bool((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(kind, node.body, operand, node, (function (l) {
-    if (isVoid) {
+  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);
-      return $this.assignTemp(tmpleft, left);
+      tmpleft = $this.forceTemp((l && l.is$Value()));
+      return $this.assignTemp((tmpleft && tmpleft.is$Value()), (left && left.is$Value()));
     }
   })
   );
-  if ($ne(tmpleft, null)) {
+  if ($notnull_bool($ne(tmpleft, null))) {
     ret = new Value(ret.type, ("(" + ret.code + ", " + tmpleft.code + ")"), false, true, false);
   }
-  if ($ne(tmpleft, left)) {
-    this.freeTemp(tmpleft);
+  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 (node.name != null) {
+  if ($notnull_bool(node.name != null)) {
     constructorName = node.name.name;
   }
-  if ($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference) && typeRef.names != null) {
+  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 (names.length == 0) names = null;
+    if ($notnull_bool(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 (type.get$isTop()) {
-    type = type.get$library().findTypeByName(constructorName);
+  if ($notnull_bool(type.get$isTop())) {
+    type = type.get$library().findTypeByName($assert_String(constructorName));
     constructorName = '';
   }
   var m = type.getConstructor(constructorName);
-  if (m == null) {
+  if ($notnull_bool(m == null)) {
     var name = type.get$jsname();
-    if (type.get$isVar()) {
+    if ($notnull_bool(type.get$isVar())) {
       name = typeRef.get$name().get$name();
     }
     world.error(('no matching constructor for ' + name + ''), node.span);
-    return this._makeMissingValue(name);
+    return this._makeMissingValue($assert_String(name));
   }
-  if (node.isConst) {
-    if (!m.get$isConst()) {
+  if ($notnull_bool(node.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 (!this.visitValue(arg.get$value()).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);
+    var arg = this.visitValue((item && item.is$lang_Expression()));
     argValues.add(arg);
-    if (node.isConst) {
-      if (!arg.get$isConst()) {
+    if ($notnull_bool(node.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.canonicalCode);
       }
     }
     else {
       argsCode.add(arg.code);
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed();
-  var code = ('[' + Strings.join(argsCode, ", ") + ']');
+  var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var value = new Value(world.listType, code, false, true, false);
-  if (node.isConst) {
+  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, argValues, ('const ' + code + ''), result.code, node.span), argValues);
+    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;
-   i < node.items.length; i += 2) {
-    var key = this.visitTypedValue(node.items.$index(i), world.stringType);
+   $notnull_bool(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);
+    var value = this.visitValue((valueItem && valueItem.is$lang_Expression()));
     argValues.add(key);
     argValues.add(value);
-    if (node.isConst) {
-      if (!key.get$isConst() || !value.get$isConst()) {
+    if ($notnull_bool(node.isConst)) {
+      if ($notnull_bool(!key.get$isConst() || !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.canonicalCode);
         argsCode.add(value.canonicalCode);
       }
     }
     else {
       argsCode.add(key.code);
       argsCode.add(value.code);
     }
   }
-  var argList = ('[' + Strings.join(argsCode, ", ") + ']');
+  var argList = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var code = ('\$map(' + argList + ')');
-  if (node.isConst) {
+  if ($notnull_bool(node.isConst)) {
     var immutableMap = world.get$coreimpl().types.$index('ImmutableMap');
     var immutableMapCtor = immutableMap.getConstructor('');
     var argsValue = new Value(world.listType, argList, false, true, false);
     var result = immutableMapCtor.invoke$4(this, node, null, new Arguments(null, [argsValue]));
-    var value = ConstMapValue.ConstMapValue$factory(immutableMap, argValues, code, result.code, node.span);
-    return world.gen.globalForConst(value, argValues);
+    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, result.code, node.span);
+    return world.gen.globalForConst(value, (argValues && argValues.is$List$Value()));
   }
   return new Value(mapImplType, code, false, true, false);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
+  var $0;
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ('' + test.code + ' ? ' + trueBranch.code + ' : ' + falseBranch.code + '');
-  return new Value(lang_Type.union(trueBranch.type, falseBranch.type), code, false, true, false);
+  return new Value(lang_Type.union((($0 = trueBranch.type) && $0.is$lang_Type()), (($0 = falseBranch.type) && $0.is$lang_Type())), code, false, true, false);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type, false);
-  return value.instanceOf(this, type, node.span, node.isTrue, false);
+  return value.instanceOf(this, (type && type.is$lang_Type()), node.span, node.isTrue, false);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var body = this.visitValue(node.body);
-  if (body.get$isConst()) {
+  if ($notnull_bool(body.get$isConst())) {
     return EvaluatedValue.EvaluatedValue$factory(body.type, body.get$actualValue(), ('(' + body.canonicalCode + ')'), node.span);
   }
   return new Value(body.type, ('(' + body.code + ')'), false, true, false);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_$3(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var ret = this._scope.lookup(node.name.name);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.method.declaringType.resolveMember(node.name.name);
-  if ($ne(ret, null)) {
+  if ($notnull_bool($ne(ret, null))) {
     return ret.get_$3(this, node, this._makeThisOrType());
   }
   ret = this.method.declaringType.get$library().lookup(node.name.name, node.span);
-  if ($ne(ret, null)) {
+  if ($notnull_bool($ne(ret, null))) {
     return ret.get_$3(this, node);
   }
   world.warning(('can not resolve ' + node.name.name + ''), node.span);
   return this._makeMissingValue(node.name.name);
 }
 MethodGenerator.prototype._makeMissingValue = function(name) {
   return new Value(null, ('' + name + '()/*NotFound*/'), false, true, false);
 }
 MethodGenerator.prototype._makeThisOrType = function() {
   var outermost = this._getOutermostMethod();
-  if (outermost.method.get$isStatic()) {
+  if ($notnull_bool(outermost.method.get$isStatic())) {
     return this._makeTypeValue(outermost.method.declaringType);
   }
   else {
     return this._makeThisValue(null);
   }
 }
 MethodGenerator.prototype._makeTypeValue = function(type) {
   return new Value(type, type.get$jsname(), false, false, true);
 }
 MethodGenerator.prototype.visitThisExpression = function(node) {
   return this._makeThisValue(node);
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(null, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  if (!!(($0 = node.value) && $0.is$List)) {
+  $assert($ne(type, null), "type != null", "gen.dart", 2018, 12);
+  if ($notnull_bool(!!(($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);
+      var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
-      if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression)) {
+      if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
         code = ('(' + code + ')');
       }
       items.add(code);
     }
-    return new Value(type, ('(' + Strings.join(items, " + ") + ')'), false, true, false);
+    return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), false, true, false);
   }
   var text = node.text;
-  if (type.get$isString()) {
-    if (text.startsWith('@')) {
-      text = MethodGenerator._escapeString(parseStringLiteral(text));
+  if ($notnull_bool(type.get$isString())) {
+    if ($notnull_bool(text.startsWith('@'))) {
+      text = MethodGenerator._escapeString(parseStringLiteral($assert_String(text)));
       text = ('"' + text + '"');
     }
-    else if (isMultilineString(text)) {
-      text = parseStringLiteral(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 (text !== node.text) {
+    if ($notnull_bool(text !== node.text)) {
       node.value = text;
-      node.text = text;
+      node.text = $assert_String(text);
     }
   }
   return EvaluatedValue.EvaluatedValue$factory(type, node.value, node.text, null);
 }
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
-  return this.visitPostfixExpression($0, false);
+  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 values0 = [];
   for (var i = 0;
-   i < arity; i++) {
+   $notnull_bool(i < arity); i++) {
     values0.add(new Value(world.varType, ('\$' + i + ''), false, false, false));
   }
   return new Arguments(null, values0);
 }
 Arguments.get$EMPTY = function() {
-  if (Arguments._empty == null) {
+  if ($notnull_bool(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();
-   i < this.get$length(); i++) {
-    if (this.getName(i) == name) {
+   $notnull_bool(i < this.get$length()); i++) {
+    if ($notnull_bool(this.getName(i) == name)) {
       return i;
     }
   }
   return -1;
 }
 Arguments.prototype.getValue = function(name) {
   var i = this.getIndexOfName(name);
-  return i >= 0 ? this.values.$index(i) : null;
+  return $notnull_bool(i >= 0) ? this.values.$index(i) : null;
 }
 Arguments.prototype.get$bareCount = function() {
-  if (this._bareCount == null) {
+  if ($notnull_bool(this._bareCount == null)) {
     this._bareCount = this.get$length();
-    if (this.nodes != null) {
+    if ($notnull_bool(this.nodes != null)) {
       for (var i = 0;
-       i < this.nodes.length; i++) {
-        if (this.nodes.$index(i).label != null) {
+       $notnull_bool(i < this.nodes.length); i++) {
+        if ($notnull_bool(this.nodes.$index(i).label != null)) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = 0;
-   i < this.get$length(); i++) {
+   $notnull_bool(i < this.get$length()); i++) {
     argsCode.add(this.values.$index(i).code);
   }
-  Arguments.removeTrailingNulls(argsCode);
-  return Strings.join(argsCode, ", ");
+  Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
+  return Strings.join((argsCode && argsCode.is$List$String()), ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
-  while (argsCode.length > 0 && $eq(argsCode.last(), 'null')) {
+  while ($notnull_bool(argsCode.length > 0 && $eq(argsCode.last(), 'null'))) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
-   i < this.get$length(); i++) {
+   $notnull_bool(i < this.get$length()); i++) {
     names.add(this.getName(i));
   }
   return names;
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = 0;
-   i < this.get$bareCount(); i++) {
+   $notnull_bool(i < this.get$bareCount()); i++) {
     result.add(new Value(world.varType, ('\$' + i + ''), false, false, false));
   }
   for (var i = this.get$bareCount();
-   i < this.get$length(); i++) {
+   $notnull_bool(i < this.get$length()); i++) {
     var name = this.getName(i);
-    if (name == null) name = ('\$' + i + '');
+    if ($notnull_bool(name == null)) name = ('\$' + i + '');
     result.add(new Value(world.varType, name, false, false, false));
   }
   return new Arguments(this.nodes, result);
 }
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix) {
   this.library = library;
   this.prefix = prefix;
   // Initializers done
 }
@@ skipping 14 matching lines @@
 }
 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 (this._jsname == null) {
+  if ($notnull_bool(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 (filename.startsWith('dart:')) return filename;
-  if (filename.startsWith('/')) return filename;
-  if (filename.startsWith('file:///')) return filename;
-  if (filename.startsWith('http://')) return 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;
   return joinPaths(this.sourceDir, filename);
 }
 Library.prototype.addImport = function(fullname, prefix) {
   this.imports.add(new LibraryImport(world.getOrAddLibrary(fullname), prefix));
 }
 Library.prototype.addNative = function(fullname) {
   this.natives.add(world.reader.readFile(fullname));
 }
 Library.prototype._findMembers = function(name0) {
-  if (name0.startsWith('_')) {
+  if ($notnull_bool(name0.startsWith('_'))) {
     return this._privateMembers.$index(name0);
   }
   else {
     return world._members.$index(name0);
   }
 }
 Library.prototype._addMember = function(member) {
-  if (member.get$isPrivate()) {
-    if (member.get$isStatic()) {
-      if (member.declaringType.get$isTop()) {
+  var $0;
+  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 (mset == null) {
+    if ($notnull_bool(mset == null)) {
       var $list = world.libraries.getValues();
       for (var $i = world.libraries.getValues().iterator(); $i.hasNext(); ) {
         var lib = $i.next();
-        if (lib._privateMembers.containsKey(member.name)) {
+        if ($notnull_bool(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.members.add(member);
     }
   }
   else {
     world._addMember(member);
   }
 }
 Library.prototype.getOrAddFunctionType = function(name0, func, inType) {
   var def = new FunctionTypeDefinition(func, null, func.span);
   var type = new DefinedType(name0, this, def, false);
   type.addMethod('\$call', func);
   type.members.$index('\$call').resolve(inType);
   type.interfaces = [world.functionType];
   return type;
 }
 Library.prototype.addType = function(name0, definition, isClass) {
-  if (this.types.containsKey(name0)) {
+  if ($notnull_bool(this.types.containsKey(name0))) {
     var existingType = this.types.$index(name0);
-    if (this.get$isCore() && existingType.get$definition() == null) {
-      existingType.setDefinition(definition);
+    if ($notnull_bool(this.get$isCore() && existingType.get$definition() == null)) {
+      existingType.setDefinition((definition && definition.is$Definition()));
     }
     else {
       world.warning(('duplicate definition of ' + name0 + ''), definition.span);
     }
   }
   else {
-    this.types.$setindex(name0, new DefinedType(name0, this, definition, isClass));
+    this.types.$setindex(name0, new DefinedType(name0, this, (definition && definition.is$Definition()), isClass));
   }
   return this.types.$index(name0);
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
-  if (result == null) return null;
-  if (type.names != null) {
-    if (type.names.length > 1) {
+  if ($notnull_bool(result == null)) return null;
+  if ($notnull_bool(type.names != null)) {
+    if ($notnull_bool(type.names.length > 1)) {
       return null;
     }
-    if (!result.get$isTop()) {
+    if ($notnull_bool(!result.get$isTop())) {
       return null;
     }
-    return result.get$library().findTypeByName(type.names.$index(0).get$name());
+    return result.get$library().findTypeByName($assert_String(type.names.$index(0).get$name()));
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name0) {
   var ret = this.types.$index(name0);
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
     var newRet = null;
-    if (imported.prefix == null) {
+    if ($notnull_bool(imported.prefix == null)) {
       newRet = imported.get$library().types.$index(name0);
     }
-    else if (imported.prefix == name0) {
+    else if ($notnull_bool(imported.prefix == name0)) {
       newRet = imported.get$library().topType;
     }
-    if ($ne(newRet, null)) {
-      if ($ne(ret, null) && $ne(ret, newRet)) {
+    if ($notnull_bool($ne(newRet, null))) {
+      if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
         world.error(('conflicting types for "' + name0 + '"'), ret.get$span());
         world.error(('conflicting types for "' + name0 + '"'), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
   }
   return ret;
 }
 Library.prototype.lookup = function(name0, span0) {
   var retType = this.findTypeByName(name0);
   var ret = null;
-  if ($ne(retType, null)) {
+  if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name0);
-  if ($ne(newRet, null)) {
-    if ($ne(ret, null) && $ne(ret, newRet)) {
+  if ($notnull_bool($ne(newRet, null))) {
+    if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
       world.error(('conflicting members for "' + name0 + '"'), span0);
       world.error(('conflicting members for "' + name0 + '"'), ret.get$span());
       world.error(('conflicting members for "' + name0 + '"'), newRet.get$span());
     }
     else {
       ret = newRet;
     }
   }
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
-    if (imported.prefix == null) {
+    if ($notnull_bool(imported.prefix == null)) {
       newRet = imported.get$library().topType.getMember(name0);
-      if ($ne(newRet, null)) {
-        if ($ne(ret, null) && $ne(ret, newRet)) {
+      if ($notnull_bool($ne(newRet, null))) {
+        if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
           world.error(('conflicting members for "' + name0 + '"'), span0);
           world.error(('conflicting members for "' + name0 + '"'), ret.get$span());
           world.error(('conflicting members for "' + name0 + '"'), newRet.get$span());
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   return ret;
 }
 Library.prototype.resolve = function() {
-  if (this.name == null) {
+  var $0;
+  if ($notnull_bool(this.name == null)) {
     this.name = this.baseSource.filename;
     var index = this.name.lastIndexOf('/', this.name.length);
-    if (index >= 0) {
+    if ($notnull_bool(index >= 0)) {
       this.name = this.name.substring(index + 1);
     }
     index = this.name.indexOf('.', 0);
-    if (index > 0) {
+    if ($notnull_bool(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.toString = function() {
   return this.baseSource.filename;
 }
 // ********** Code for LibraryVisitor **************
 function LibraryVisitor(library) {
   this.library = library;
   // Initializers done
   this.currentType = this.library.topType;
   this.sources = [];
   this.addSource(this.library.baseSource);
 }
 LibraryVisitor.prototype.get$library = function() { return this.library; };
 LibraryVisitor.prototype.addSourceFromName = function(name) {
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 LibraryVisitor.prototype.addSource = function(source) {
+  var $0;
   this.library.sources.add(source);
   var parser = new lang_Parser(source, options.dietParse, 0);
   var unit = parser.compilationUnit();
   for (var $i = 0;$i < unit.length; $i++) {
     var def = unit.$index($i);
     def.visit(this);
   }
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
-    this.addSource(source0);
+    this.addSource((source0 && source0.is$SourceFile()));
   }
 }
 LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
-      if (this.library.name == null) {
-        this.library.name = name;
-        if ($eq(name, 'node') || $eq(name, 'dom')) {
+      if ($notnull_bool(this.library.name == null)) {
+        this.library.name = $assert_String(name);
+        if ($notnull_bool($eq(name, 'node') || $eq(name, 'dom'))) {
           this.library.topType.isNativeType = true;
         }
       }
       else {
         world.error('already specified library name', node.span);
       }
       break;
 
     case "import":
 
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
-      if (node.arguments.length > 2 || node.arguments.length == 2 && prefix == null) {
+      if ($notnull_bool(node.arguments.length > 2 || 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 ($ne(prefix, null) && prefix.indexOf('.', 0) >= 0) {
+      else if ($notnull_bool($ne(prefix, null) && prefix.indexOf('.', 0) >= 0)) {
         world.error('library prefix canot contain "."', node.span);
       }
-      if ($eq(prefix, '')) prefix = null;
-      this.library.addImport(this.library.makeFullPath(name), prefix);
+      if ($notnull_bool($eq(prefix, ''))) prefix = null;
+      this.library.addImport(this.library.makeFullPath($assert_String(name)), $assert_String(prefix));
       break;
 
     case "source":
 
       name = this.getSingleStringArg(node);
-      this.addSourceFromName(name);
+      this.addSourceFromName($assert_String(name));
       break;
 
     case "native":
 
       name = this.getSingleStringArg(node);
-      this.library.addNative(this.library.makeFullPath(name));
+      this.library.addNative(this.library.makeFullPath($assert_String(name)));
       break;
 
     case "resource":
 
       this.getFirstStringArg(node);
       break;
 
     default:
 
       world.error(('unknown directive: ' + node.name.name + ''), node.span);
 
   }
 }
 LibraryVisitor.prototype.getSingleStringArg = function(node) {
-  if (node.arguments.length != 1) {
+  if ($notnull_bool(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 (node.arguments.length < 1) {
+  if ($notnull_bool(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 (arg.label != null) {
+  if ($notnull_bool(arg.label != null)) {
     world.error('label not allowed for directive', node.span);
   }
-  return this._parseStringArgument(arg);
+  return this._parseStringArgument((arg && arg.is$ArgumentNode()));
 }
 LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
+  var $0;
   var args = node.arguments.filter((function (a) {
     return a.label != null && a.label.name == argName;
   })
   );
-  if (args.length == 0) {
+  if ($notnull_bool(args.length == 0)) {
     return null;
   }
-  if (args.length > 1) {
+  if ($notnull_bool(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);
+    return this._parseStringArgument((arg && arg.is$ArgumentNode()));
   }
 }
 LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
-  if (!(expr instanceof LiteralExpression) || !expr.type.type.get$isString()) {
+  if ($notnull_bool(!(expr instanceof LiteralExpression) || !expr.type.type.get$isString())) {
     world.error('expected string', expr.get$span());
   }
-  return parseStringLiteral(expr.get$value());
+  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);
     member.visit(this);
   }
-  this.currentType = oldType;
+  this.currentType = (oldType && oldType.is$lang_Type());
 }
 LibraryVisitor.prototype.visitVariableDefinition = function(node) {
   this.currentType.addField(node);
 }
 LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
 LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod('\$call', node.func);
 }
 // ********** Code for lang_Parameter **************
 function lang_Parameter(definition) {
   this.definition = definition;
   // Initializers done
 }
 lang_Parameter.prototype.get$definition = function() { return this.definition; };
 lang_Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 lang_Parameter.prototype.get$name = function() { return this.name; };
 lang_Parameter.prototype.set$name = function(value) { return this.name = value; };
 lang_Parameter.prototype.get$value = function() { return this.value; };
 lang_Parameter.prototype.set$value = function(value) { return this.value = value; };
 lang_Parameter.prototype.resolve = function(inType) {
   this.name = this.definition.name.name;
   this.type = inType.resolveType(this.definition.type, false);
 }
 lang_Parameter.prototype.genValue = function(method, context) {
-  if (this.definition.value == null || this.value != null) return;
-  if (context == null) {
+  var $0;
+  if ($notnull_bool(this.definition.value == null || this.value != null)) return;
+  if ($notnull_bool(context == null)) {
     context = new MethodGenerator(method, null);
   }
-  this.value = this.definition.value.visit(context);
+  this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 lang_Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new lang_Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   return ret;
 }
 lang_Parameter.prototype.get$isOptional = function() {
   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 this._jsname == null ? this.name : this._jsname;
+  return $notnull_bool(this._jsname == null) ? this.name : this._jsname;
 }
 Member.prototype.set$jsname = function(name0) {
   return this._jsname = name0;
 }
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
   return this.name.startsWith('_');
 }
@@ skipping 37 matching lines @@
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return this.get$canGet() && new Value(this.get$returnType(), null, false, true, false).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 (this.get$isStatic()) {
+  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 (other.get$isStatic()) {
+  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", 132, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
-  if (this.name == '') {
+  if ($notnull_bool(this.name == '')) {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
-Member.prototype.get_$3 = Member.prototype.get_;
-Member.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+Member.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()));
 }
 ;
-Member.prototype.set_$4 = Member.prototype.set_;
+Member.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()), false);
+}
+;
+Member.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()));
+}
+;
 // ********** Code for TypeMember **************
 function TypeMember(type0) {
   this.type = type0;
   Member.call(this, type0.name, type0.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
   return world.get$isVar();
 }
 TypeMember.prototype.canInvoke = function(context, args) {
   return false;
 }
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
 TypeMember.prototype.resolve = function(inType) {
 
 }
 TypeMember.prototype.get_ = function(context, node, target, isDynamic) {
+  $assert(target == null || target.type.get$isTop(), "target == null || target.type.isTop", "member.dart", 170, 12);
   return new Value(this.type, this.type.get$jsname(), false, false, true);
 }
 TypeMember.prototype.set_ = function(context, node, target, value, isDynamic) {
   world.error('can not set type', this.type.definition.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', this.type.definition.span);
 }
 TypeMember.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 TypeMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 }
 ;
 TypeMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for FieldMember **************
 function FieldMember(name0, declaringType0, definition, value) {
   this._providePropertySyntax = false
   this._computing = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $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 (!Member.prototype.override.call(this, other)) return false;
-  if (other.get$isProperty()) {
+  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() {
   return this._providePropertySyntax = true;
 }
 FieldMember.prototype.get$span = function() {
-  return this.definition == null ? null : this.definition.span;
+  return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 FieldMember.prototype.get$returnType = function() {
   return this.type;
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !this.isFinal;
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function(inType) {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
-  if (this.definition.modifiers != null) {
+  if ($notnull_bool(this.definition.modifiers != null)) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
-      if (mod.kind == 85/*TokenKind.STATIC*/) {
-        if (this.isStatic) {
+      if ($notnull_bool(mod.kind == 86/*TokenKind.STATIC*/)) {
+        if ($notnull_bool(this.isStatic)) {
           world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
-      else if (mod.kind == 96/*TokenKind.FINAL*/) {
-        if (this.isFinal) {
+      else if ($notnull_bool(mod.kind == 97/*TokenKind.FINAL*/)) {
+        if ($notnull_bool(this.isFinal)) {
           world.error('duplicate final modifier', mod.get$span());
         }
         this.isFinal = true;
       }
       else {
         world.error(('' + mod + ' modifier not allowed on field'), mod.get$span());
       }
     }
   }
   this.type = inType.resolveType(this.definition.type, false);
-  if (this.isStatic && this.type.get$hasTypeParams()) {
+  if ($notnull_bool(this.isStatic && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.type.span);
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
-  if (this.value == null) return null;
-  if (this._computedValue == null) {
-    if (this._computing) {
+  var $0;
+  if ($notnull_bool(this.value == null)) return null;
+  if ($notnull_bool(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 = this.value.visit(finalGen);
-    if (!this._computedValue.get$isConst()) {
-      if (this.isStatic) {
+    this._computedValue = (($0 = this.value.visit(finalGen)) && $0.is$Value());
+    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 (this.isStatic) {
+    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) {
-  if (!isDynamic) {
+  if ($notnull_bool(!isDynamic)) {
     this.declaringType.markUsed();
   }
-  if (this.isStatic) {
+  if ($notnull_bool(this.isStatic)) {
     var cv = this.computeValue();
-    if (this.isFinal) {
+    if ($notnull_bool(this.isFinal)) {
       return cv;
     }
-    if (this.declaringType.get$isTop()) {
+    if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), false, true, false);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), false, true, false);
     }
   }
-  else if (target.get$isConst() && this.isFinal) {
-    var constTarget = (target instanceof GlobalValue) ? target.exp : target;
-    if ((constTarget instanceof ConstObjectValue)) {
+  else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
+    var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.exp : target;
+    if ($notnull_bool((constTarget instanceof ConstObjectValue))) {
       return constTarget.fields.$index(this.name);
     }
-    else if ($eq(constTarget.type, world.stringType) && this.name == 'length') {
+    else if ($notnull_bool($eq(constTarget.type, world.stringType) && this.name == 'length')) {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), false, true, false);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), false, true, false);
 }
 FieldMember.prototype.set_ = function(context, node, target, value0, isDynamic) {
   var lhs = this.get_(context, node, target, isDynamic);
   value0 = value0.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.code + ' = ' + value0.code + ''), false, true, false);
 }
 FieldMember.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 FieldMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for PropertyMember **************
 function PropertyMember(name0, declaringType0) {
   this._provideFieldSyntax = false
   Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
+PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$span = function() {
-  return this.getter != null ? this.getter.get$span() : null;
+  return $notnull_bool(this.getter != null) ? this.getter.get$span() : null;
 }
 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() {
   return this._provideFieldSyntax = true;
 }
 PropertyMember.prototype.providePropertySyntax = function() {
 
 }
 PropertyMember.prototype.get$isStatic = function() {
-  return this.getter == null ? this.setter.isStatic : this.getter.isStatic;
+  return $notnull_bool(this.getter == null) ? this.setter.isStatic : this.getter.isStatic;
 }
 PropertyMember.prototype.get$isProperty = function() {
   return true;
 }
 PropertyMember.prototype.get$returnType = function() {
-  return this.getter == null ? this.setter.returnType : this.getter.returnType;
+  return $notnull_bool(this.getter == null) ? this.setter.returnType : this.getter.returnType;
 }
 PropertyMember.prototype.override = function(other) {
-  if (!Member.prototype.override.call(this, other)) return false;
-  if (other.get$isProperty() || other.get$isField()) {
-    if (other.get$isProperty()) this.addFromParent(other);
+  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);
     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 (this.getter == null) {
+  if ($notnull_bool(this.getter == null)) {
     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) {
   return this.setter.invoke(context, node, target, new Arguments(null, [value]), isDynamic);
 }
 PropertyMember.prototype.addFromParent = function(parentMember) {
-  if ((parentMember instanceof ConcreteMember)) {
+  if ($notnull_bool((parentMember instanceof ConcreteMember))) {
     parentMember = parentMember.baseMember;
   }
-  if (this.getter == null) this.getter = parentMember.getter;
-  if (this.setter == null) this.setter = parentMember.setter;
+  if ($notnull_bool(this.getter == null)) this.getter = parentMember.getter;
+  if ($notnull_bool(this.setter == null)) this.setter = parentMember.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
-  if (this.getter != null) this.getter.resolve(inType);
-  if (this.setter != null) this.setter.resolve(inType);
+  if ($notnull_bool(this.getter != null)) this.getter.resolve(inType);
+  if ($notnull_bool(this.setter != null)) this.setter.resolve(inType);
   this.get$library()._addMember(this);
 }
 PropertyMember.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  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, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name0, declaringType0, baseMember) {
   this.baseMember = baseMember;
   Member.call(this, name0, declaringType0);
   // Initializers done
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType0);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     var newType = p.type.resolveTypeParams(declaringType0);
-    if ($ne(newType, p.type)) {
-      this.parameters.add(p.copyWithNewType(newType));
+    if ($notnull_bool($ne(newType, p.type))) {
+      this.parameters.add(p.copyWithNewType((newType && newType.is$lang_Type())));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 $inherits(ConcreteMember, Member);
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
 ConcreteMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 ConcreteMember.prototype.get$parameters = function() { return this.parameters; };
@@ skipping 75 matching lines @@
   var ret = this.baseMember.get_(context, node, target, isDynamic);
   return new Value(this.returnType, ret.code, false, true, false);
 }
 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, false, true, false);
 }
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.code;
-  if (this.get$isConstructor()) {
+  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, false, true, false);
 }
 ConcreteMember.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 }
 ;
 ConcreteMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for MethodMember **************
 function MethodMember(name0, declaringType0, definition) {
   this.isStatic = false
   this.isAbstract = false
   this.isConst = false
   this.isFactory = false
   this.isLambda = false
   this._providePropertySyntax = false
   this._provideFieldSyntax = false
   this._provideOptionalParamInfo = false
   this.definition = definition;
   Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(MethodMember, Member);
+MethodMember.prototype.is$MethodMember = function(){return this;};
 MethodMember.prototype.get$definition = function() { return this.definition; };
 MethodMember.prototype.set$definition = function(value) { return this.definition = value; };
 MethodMember.prototype.get$returnType = function() { return this.returnType; };
 MethodMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 MethodMember.prototype.get$parameters = function() { return this.parameters; };
 MethodMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 MethodMember.prototype.get$isAbstract = function() { return this.isAbstract; };
 MethodMember.prototype.set$isAbstract = function(value) { return this.isAbstract = value; };
@@ skipping 12 matching lines @@
 MethodMember.prototype.get$isNative = function() {
   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() {
-  return this.definition == null ? null : this.definition.span;
+  return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 MethodMember.prototype.get$constructorName = function() {
-  if (this.definition.returnType == null) return '';
-  if (this.definition.returnType.names != null) {
+  if ($notnull_bool(this.definition.returnType == null)) return '';
+  if ($notnull_bool(this.definition.returnType.names != null)) {
     return this.definition.returnType.names.$index(0).get$name();
   }
-  else if ($ne(this.definition.returnType.get$name(), null)) {
+  else if ($notnull_bool($ne(this.definition.returnType.get$name(), null))) {
     return this.definition.returnType.get$name().get$name();
   }
   world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
-  if (this._functionType == null) {
+  if ($notnull_bool(this._functionType == null)) {
     this._functionType = this.declaringType.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
-    if (this.parameters == null) {
+    if ($notnull_bool(this.parameters == null)) {
       this.resolve(this.declaringType);
     }
   }
   return this._functionType;
 }
 MethodMember.prototype.override = function(other) {
-  if (!Member.prototype.override.call(this, other)) return false;
-  if (other.get$isMethod()) {
+  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 (bareCount > this.parameters.length) return false;
-  if (bareCount == this.parameters.length) {
-    if (bareCount != args.get$length()) return false;
+  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;
   }
   else {
-    if (!this.parameters.$index(bareCount).get$isOptional()) return false;
+    if ($notnull_bool(!this.parameters.$index(bareCount).get$isOptional())) return false;
     for (var i = bareCount;
-     i < args.get$length(); i++) {
-      if (this.indexOfParameter(args.getName(i)) < 0) {
+     $notnull_bool(i < args.get$length()); i++) {
+      if ($notnull_bool(this.indexOfParameter(args.getName(i)) < 0)) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name0) {
   for (var i = 0;
-   i < this.parameters.length; i++) {
+   $notnull_bool(i < this.parameters.length); i++) {
     var p = this.parameters.$index(i);
-    if (p.get$isOptional() && $eq(p.get$name(), name0)) {
+    if ($notnull_bool(p.get$isOptional() && $eq(p.get$name(), name0))) {
       return i;
     }
   }
   return -1;
 }
 MethodMember.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
-  if (this.isStatic && type.get$hasTypeParams()) {
+  if ($notnull_bool(this.isStatic && type.get$hasTypeParams())) {
     world.error('using type parameter in static context', node.span);
   }
   return type;
 }
 MethodMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 MethodMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   return this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
   return this._providePropertySyntax = true;
 }
 MethodMember.prototype.set_ = function(context, Node0, target, value, isDynamic) {
   world.error('can not set method', this.definition.span);
 }
 MethodMember.prototype.get_ = function(context, node, target, isDynamic) {
   this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
-  if (this.isStatic) {
-    var type = this.declaringType.get$isTop() ? '' : ('' + this.declaringType.get$jsname() + '.');
+  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() + ''), false, true, false);
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), false, true, false);
 }
 MethodMember.prototype.namesInOrder = function(args) {
-  if (!args.get$hasNames()) return true;
+  if ($notnull_bool(!args.get$hasNames())) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
-   i < this.parameters.length; i++) {
-    var p = args.getIndexOfName(this.parameters.$index(i).get$name());
-    if (p >= 0 && args.values.$index(p).needsTemp) {
-      if (lastParameter != null && lastParameter > p) {
+   $notnull_bool(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))) {
         return false;
       }
-      lastParameter = p;
+      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++) {
+    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)) {
+    this.genParameterValues();
+    for (var i = bareCount;
+     $notnull_bool(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 ' + ('' + (atLeast ? "at least " : "") + '' + expected + ' but found ' + actual + '');
+  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 (this.isStatic || this.get$isConstructor()) {
+  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) {
-  if (this.parameters == null) {
+  var $0;
+  if ($notnull_bool(this.parameters == null)) {
     world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name + ''));
     this.resolve(this.declaringType);
   }
   this.declaringType.genMethod(this);
-  if (this.isStatic || this.isFactory) {
+  if ($notnull_bool(this.isStatic || this.isFactory)) {
     this.declaringType.markUsed();
   }
-  if (!this.namesInOrder(args)) {
+  if ($notnull_bool(!this.namesInOrder(args))) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
-  if (target != null && (this.get$isConstructor() || target.isSuper)) {
+  if ($notnull_bool(target != null && (this.get$isConstructor() || target.isSuper))) {
     argsCode.add('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
-   i < bareCount; i++) {
+   $notnull_bool(i < bareCount); i++) {
     var arg = args.values.$index(i);
-    if (i >= this.parameters.length) {
+    if ($notnull_bool(i >= this.parameters.length)) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.length, false);
-      return this._argError(context, node, target, args, msg);
+      return this._argError(context, node, target, args, $assert_String(msg));
     }
-    arg = arg.convertTo(context, this.parameters.$index(i).type, node, isDynamic);
-    if (this.isConst && arg.get$isConst()) {
+    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.canonicalCode);
     }
     else {
       argsCode.add(arg.code);
     }
   }
-  if (bareCount < this.parameters.length) {
+  if ($notnull_bool(bareCount < this.parameters.length)) {
     this.genParameterValues();
     var namedArgsUsed = 0;
     for (var i = bareCount;
-     i < this.parameters.length; i++) {
-      var arg = args.getValue(this.parameters.$index(i).get$name());
-      if (arg == null) {
+     $notnull_bool(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, this.parameters.$index(i).type, node, isDynamic);
+        arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
         namedArgsUsed++;
       }
-      if (arg == null || !this.parameters.$index(i).get$isOptional()) {
+      if ($notnull_bool(arg == null || !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, msg);
+        return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
-        argsCode.add(this.isConst && arg.get$isConst() ? arg.canonicalCode : arg.code);
+        argsCode.add($notnull_bool(this.isConst && arg.get$isConst()) ? arg.canonicalCode : arg.code);
       }
     }
-    if (namedArgsUsed < args.get$nameCount()) {
+    if ($notnull_bool(namedArgsUsed < args.get$nameCount())) {
       var seen = new HashSetImplementation$String();
       for (var i = bareCount;
-       i < args.get$length(); i++) {
+       $notnull_bool(i < args.get$length()); i++) {
         var name0 = args.getName(i);
-        if (seen.contains(name0)) {
+        if ($notnull_bool(seen.contains(name0))) {
           return this._argError(context, node, target, args, ('duplicate argument "' + name0 + '"'));
         }
         seen.add(name0);
-        var p = this.indexOfParameter(name0);
-        if (p < 0) {
+        var p = this.indexOfParameter($assert_String(name0));
+        if ($notnull_bool(p < 0)) {
           return this._argError(context, node, target, args, ('method does not have optional parameter "' + name0 + '"'));
         }
-        else if (p < bareCount) {
+        else if ($notnull_bool(p < bareCount)) {
           return this._argError(context, node, target, args, ('argument "' + name0 + '" passed as positional and named'));
         }
       }
       world.internalError(('wrong named arguments calling ' + this.name + ''), node.span);
     }
-    Arguments.removeTrailingNulls(argsCode);
+    Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
   }
-  var argsString = Strings.join(argsCode, ', ');
-  if (this.get$isConstructor()) {
+  var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
+  if ($notnull_bool(this.get$isConstructor())) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
-  if (this.name.startsWith('\$')) {
+  if ($notnull_bool(this.name.startsWith('\$'))) {
     return this._invokeBuiltin(context, node, target, args, argsCode);
   }
-  if (target != null && target.isSuper) {
+  if ($notnull_bool(target != null && target.isSuper)) {
     return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), false, true, false);
   }
-  if (this.isFactory) {
+  if ($notnull_bool(this.isFactory)) {
     return new Value(this.returnType, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), false, true, false);
   }
-  if (this.isStatic) {
-    if (this.declaringType.get$isTop()) {
+  if ($notnull_bool(this.isStatic)) {
+    if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
     }
     return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
-  if (target.get$isConst()) {
-    if ((target instanceof GlobalValue)) {
+  if ($notnull_bool(target.get$isConst())) {
+    if ($notnull_bool((target instanceof GlobalValue))) {
       target = target.exp;
     }
-    if (this.name == 'get\$length') {
-      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
+    if ($notnull_bool(this.name == 'get\$length')) {
+      if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
         code = ('' + target.values.length + '');
       }
     }
-    else if (this.name == 'isEmpty') {
-      if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
+    else if ($notnull_bool(this.name == 'isEmpty')) {
+      if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
         code = ('' + target.values.isEmpty() + '');
       }
     }
   }
   return new Value(this.returnType, code, false, true, false);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
-  if (target != null) {
-    var code = (this.get$constructorName() != '') ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
+  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 + ')');
     return new Value(this.declaringType, code, false, true, false);
   }
   else {
-    var code = (this.get$constructorName() != '') ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
-    if (this.isConst && node.get$isConst()) {
-      return this._invokeConstConstructor(node, code, target, args);
+    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.get$isConst())) {
+      return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
       return new Value(this.declaringType, code, false, true, false);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
+  var $0;
   var fields = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
-   i < this.parameters.length; i++) {
+   $notnull_bool(i < this.parameters.length); i++) {
     var param = this.parameters.$index(i).get$name();
-    if (param.startsWith('this.')) {
+    if ($notnull_bool(param.startsWith('this.'))) {
       var fname = param.substring(5);
       var value = null;
-      if (i < args.get$length()) {
+      if ($notnull_bool(i < args.get$length())) {
         value = args.values.$index(i);
       }
       else {
-        value = args.getValue(this.parameters.$index(i).get$name());
-        if (value == null) {
+        value = args.getValue($assert_String(this.parameters.$index(i).get$name()));
+        if ($notnull_bool(value == null)) {
           value = this.parameters.$index(i).get$value();
         }
       }
       fields.$setindex(fname, value);
     }
   }
-  if (this.definition.initializers != null) {
+  if ($notnull_bool(this.definition.initializers != null)) {
     this.generator._pushBlock(false);
     for (var j = 0;
-     j < this.definition.formals.length; j++) {
+     $notnull_bool(j < this.definition.formals.length); j++) {
       var name0 = this.definition.formals.$index(j).get$name().get$name();
       var value = null;
-      if (j < args.get$length()) {
+      if ($notnull_bool(j < args.get$length())) {
         value = args.values.$index(j);
       }
       else {
-        value = args.getValue(this.parameters.$index(j).get$name());
-        if (value == null) {
+        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(name0, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
-      if ((init instanceof CallExpression)) {
-        var delegateArgs = this.generator._makeArgs(init.get$arguments());
+      if ($notnull_bool((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 ((init.target instanceof ThisExpression)) {
+        if ($notnull_bool((init.target instanceof ThisExpression))) {
           return value;
         }
         else {
-          if ((value instanceof GlobalValue)) {
+          if ($notnull_bool((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 fname = init.x.get$name().get$name();
         var val = this.generator.visitValue(init.y);
         fields.$setindex(fname, val);
       }
     }
     this.generator._popBlock();
   }
   var $list = this.declaringType.members.getValues();
   for (var $i = this.declaringType.members.getValues().iterator(); $i.hasNext(); ) {
     var f = $i.next();
-    if ((f instanceof FieldMember) && !f.get$isStatic() && $ne(f.get$value(), null) && !fields.containsKey(f.get$name())) {
+    if ($notnull_bool((f instanceof FieldMember) && !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) {
   var allConst = target.get$isConst() && args.values.every((function (arg) {
     return arg.get$isConst();
   })
   );
-  if (this.declaringType.get$isNum()) {
-    if (!allConst) {
+  if ($notnull_bool(this.declaringType.get$isNum())) {
+    if ($notnull_bool(!allConst)) {
       var code;
-      if (this.name == '\$negate') {
+      if ($notnull_bool(this.name == '\$negate')) {
         code = ('-' + target.code + '');
       }
-      else if (this.name == '\$bit_not') {
+      else if ($notnull_bool(this.name == '\$bit_not')) {
         code = ('~' + target.code + '');
       }
-      else if (this.name == '\$truncdiv') {
+      else if ($notnull_bool(this.name == '\$truncdiv')) {
         code = ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')');
       }
-      else if (this.name == '\$mod') {
+      else if ($notnull_bool(this.name == '\$mod')) {
         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, false, true, false);
     }
     else {
       var value;
       var val0, val1, ival0, ival1;
-      val0 = target.get$dynamic().get$actualValue();
+      val0 = $assert_num(target.get$dynamic().get$actualValue());
       ival0 = val0.toInt();
-      if (args.values.length > 0) {
-        val1 = args.values.$index(0).get$dynamic().get$actualValue();
+      if ($notnull_bool(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 87 matching lines @@
 
         case '\$shr':
 
           value = (ival0 >>> ival1).toDouble();
           break;
 
       }
       return EvaluatedValue.EvaluatedValue$factory(this.returnType, value, ("" + value + ""), node.span);
     }
   }
-  else if (this.declaringType.get$isString()) {
-    if (this.name == '\$index') {
+  else if ($notnull_bool(this.declaringType.get$isString())) {
+    if ($notnull_bool(this.name == '\$index')) {
       return new Value(this.declaringType, ('' + target.code + '[' + argsCode.$index(0) + ']'), false, true, false);
     }
-    else if (this.name == '\$add') {
-      if (allConst) {
+    else if ($notnull_bool(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 (args.values.$index(0).type.get$isString()) {
+        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, 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) + ''), false, true, false);
     }
   }
-  else if (this.declaringType.get$isNativeType()) {
-    if (this.name == '\$index') {
+  else if ($notnull_bool(this.declaringType.get$isNativeType())) {
+    if ($notnull_bool(this.name == '\$index')) {
       return new Value(null, ('' + target.code + '[' + argsCode.$index(0) + ']'), false, true, false);
     }
-    else if (this.name == '\$setindex') {
+    else if ($notnull_bool(this.name == '\$setindex')) {
       return new Value(null, ('' + target.code + '[' + argsCode.$index(0) + '] = ' + argsCode.$index(1) + ''), false, true, false);
     }
   }
-  if (this.name == '\$eq' || this.name == '\$ne') {
-    var op = this.name == '\$eq' ? '==' : '!=';
-    if (allConst) {
+  if ($notnull_bool(this.name == '\$eq' || this.name == '\$ne')) {
+    var op = $notnull_bool(this.name == '\$eq') ? '==' : '!=';
+    if ($notnull_bool(allConst)) {
       var val0 = target.get$dynamic().get$actualValue();
       var val1 = args.values.$index(0).get$dynamic().get$actualValue();
-      var newVal = this.name == '\$eq' ? $eq(val0, val1) : $ne(val0, val1);
+      var newVal = $notnull_bool(this.name == '\$eq') ? $eq(val0, val1) : $ne(val0, val1);
       return EvaluatedValue.EvaluatedValue$factory(world.boolType, newVal, ("" + newVal + ""), node.span);
     }
-    if ($eq(argsCode.$index(0), 'null')) {
+    if ($notnull_bool($eq(argsCode.$index(0), 'null'))) {
       return new Value(this.returnType, ('' + target.code + ' ' + op + ' null'), false, true, false);
     }
-    else if (target.type.get$isNum() || target.type.get$isString()) {
+    else if ($notnull_bool(target.type.get$isNum() || target.type.get$isString())) {
       return new Value(this.returnType, ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), false, true, false);
     }
     return new Value(this.returnType, ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), false, true, false);
   }
-  if (this.name == '\$call') {
+  if ($notnull_bool(this.name == '\$call')) {
     this.declaringType.markUsed();
-    return new Value(this.returnType, ('' + target.code + '(' + Strings.join(argsCode, ", ") + ')'), false, true, false);
+    return new Value(this.returnType, ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), false, true, false);
   }
   return target.invokeSpecial(this.get$jsname(), args, this.returnType);
 }
 MethodMember.prototype.resolve = function(inType) {
   this.isStatic = inType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = false;
-  if (this.definition.modifiers != null) {
+  if ($notnull_bool(this.definition.modifiers != null)) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
-      if (mod.kind == 85/*TokenKind.STATIC*/) {
-        if (this.isStatic) {
+      if ($notnull_bool(mod.kind == 86/*TokenKind.STATIC*/)) {
+        if ($notnull_bool(this.isStatic)) {
           world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
-      else if (this.get$isConstructor() && mod.kind == 90/*TokenKind.CONST*/) {
-        if (this.isConst) {
+      else if ($notnull_bool(this.get$isConstructor() && mod.kind == 91/*TokenKind.CONST*/)) {
+        if ($notnull_bool(this.isConst)) {
           world.error('duplicate const modifier', mod.get$span());
         }
         this.isConst = true;
       }
-      else if (mod.kind == 74/*TokenKind.FACTORY*/) {
-        if (this.isFactory) {
+      else if ($notnull_bool(mod.kind == 75/*TokenKind.FACTORY*/)) {
+        if ($notnull_bool(this.isFactory)) {
           world.error('duplicate factory modifier', mod.get$span());
         }
         this.isFactory = true;
       }
-      else if (mod.kind == 70/*TokenKind.ABSTRACT*/) {
-        if (this.isAbstract) {
+      else if ($notnull_bool(mod.kind == 71/*TokenKind.ABSTRACT*/)) {
+        if ($notnull_bool(this.isAbstract)) {
           world.error('duplicate abstract modifier', mod.get$span());
         }
         this.isAbstract = true;
       }
       else {
         world.error(('' + mod + ' modifier not allowed on method'), mod.get$span());
       }
     }
   }
-  if (this.isFactory) {
+  if ($notnull_bool(this.isFactory)) {
     this.isStatic = true;
   }
-  if (this.isAbstract) {
-    if (this.definition.body != null) {
+  if ($notnull_bool(this.isAbstract)) {
+    if ($notnull_bool(this.definition.body != null)) {
       world.error('abstract method can not have a body', this.definition.body.span);
     }
-    if (this.isStatic) {
+    if ($notnull_bool(this.isStatic)) {
       world.error('static method can not be abstract', this.definition.span);
     }
   }
   else {
   }
-  if (this.get$isConstructor()) {
+  if ($notnull_bool(this.get$isConstructor())) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = inType.resolveType(this.definition.returnType, false);
-    if (this.isStatic && this.returnType.get$hasTypeParams()) {
+    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 lang_Parameter(formal);
     param.resolve(inType);
     this.parameters.add(param);
-    if (this.isStatic && param.type.get$hasTypeParams()) {
+    if ($notnull_bool(this.isStatic && param.type.get$hasTypeParams())) {
       world.error('using type parameter in static context', formal.get$span());
     }
   }
-  if (!this.isLambda) {
+  if ($notnull_bool(!this.isLambda)) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 }
 ;
 MethodMember.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), $1, ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for MemberSet **************
 function MemberSet(member) {
   this.name = member.name;
   this.members = [member];
   this.jsname = member.get$jsname();
   // Initializers done
 }
 MemberSet.prototype.get$name = function() { return this.name; };
@@ skipping 14 matching lines @@
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
 MemberSet.prototype.get$library = function() {
   var ret = this.members.$index(0).declaringType.get$library();
   var $list = this.members;
   for (var $i = 0;$i < $list.length; $i++) {
     var m = $list.$index($i);
-    if ($ne(m.declaringType.get$library(), ret)) return null;
+    if ($notnull_bool($ne(m.declaringType.get$library(), ret))) return null;
   }
   return ret;
 }
 MemberSet.prototype._makeError = function(node, target, action) {
-  if (!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(null, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), false, true, false);
 }
 MemberSet.prototype.get$treatAsField = function() {
-  if (this._treatAsField == null) {
+  if ($notnull_bool(this._treatAsField == null)) {
     this._treatAsField = true;
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
-      if (member.get$requiresFieldSyntax()) {
+      if ($notnull_bool(member.get$requiresFieldSyntax())) {
         this._treatAsField = true;
         break;
       }
-      if (member.get$prefersPropertySyntax()) {
+      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 (this._treatAsField) {
+      if ($notnull_bool(this._treatAsField)) {
         member.provideFieldSyntax();
       }
       else {
         member.providePropertySyntax();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype.get_ = function(context, node, target, isDynamic) {
-  if (this.members.length == 1) {
+  var $0;
+  if ($notnull_bool(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 (targets.length == 1) {
+  if ($notnull_bool(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 (returnValue == null) {
+  if ($notnull_bool(returnValue == null)) {
     return this._makeError(node, target, 'getter');
   }
-  if (returnValue.code == null) {
-    if (this.get$treatAsField()) {
+  if ($notnull_bool(returnValue.code == null)) {
+    if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), false, true, false);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), false, true, false);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.set_ = function(context, node, target, value, isDynamic) {
-  if (this.members.length == 1) {
+  var $0;
+  if ($notnull_bool(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 (targets.length == 1) {
+  if ($notnull_bool(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);
+    returnValue = this._tryUnion(returnValue, (res && res.is$Value()), node);
   }
-  if (returnValue == null) {
+  if ($notnull_bool(returnValue == null)) {
     return this._makeError(node, target, 'setter');
   }
-  if (returnValue.code == null) {
-    if (this.get$treatAsField()) {
+  if ($notnull_bool(returnValue.code == null)) {
+    if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), false, true, false);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), false, true, false);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
-  if (this.members.length == 1) {
+  var $0;
+  if ($notnull_bool(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 (targets.length == 1) {
+  if ($notnull_bool(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);
+    returnValue = this._tryUnion(returnValue, (res && res.is$Value()), node);
   }
-  if (returnValue == null) {
+  if ($notnull_bool(returnValue == null)) {
     return this._makeError(node, target, 'method');
   }
-  if (returnValue.code == null) {
-    if (this.name.startsWith('\$')) {
+  if ($notnull_bool(returnValue.code == null)) {
+    if ($notnull_bool(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 (x == null) return y;
+  if ($notnull_bool(x == null)) return y;
   var type = lang_Type.union(x.type, y.type);
-  if (x.code == y.code) {
-    if ($eq(type, x.type)) {
+  if ($notnull_bool(x.code == y.code)) {
+    if ($notnull_bool($eq(type, x.type))) {
       return x;
     }
-    else if (x.get$isConst() || y.get$isConst()) {
+    else if ($notnull_bool(x.get$isConst() || y.get$isConst())) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       return new Value(type, x.code, x.isSuper && y.isSuper, x.needsTemp || y.needsTemp, x.isType && y.isType);
     }
   }
   else {
     return new Value(type, null, false, true, false);
   }
 }
 MemberSet.prototype.getVarMember = function(context, node, args) {
-  if (world.objectType.varStubs == null) {
+  if ($notnull_bool(world.objectType.varStubs == null)) {
     world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = world.objectType.varStubs.$index(stubName);
-  if (stub == null) {
+  if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
     var targets = mset.filter((function (m) {
       return m.canInvoke(context, args);
     })
     );
-    var returnType = reduce(map(targets, (function (t) {
+    var returnType = reduce(map((targets && targets.is$Iterable()), (function (t) {
       return t.get$returnType();
     })
     ), lang_Type.union);
-    stub = new VarMethodSet(stubName, targets, args, returnType);
+    stub = new VarMethodSet($assert_String(stubName), targets, args, returnType);
     world.objectType.varStubs.$setindex(stubName, stub);
   }
   return stub;
 }
 MemberSet.prototype.get_$3 = function($0, $1, $2) {
-  return this.get_($0, $1, $2, false);
+  return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MemberSet.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 }
 ;
 MemberSet.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
   var ret = this.factories.$index(typeName);
-  if (ret == null) {
+  if ($notnull_bool(ret == null)) {
     ret = $map([]);
     this.factories.$setindex(typeName, ret);
   }
   return ret;
 }
 FactoryMap.prototype.addFactory = function(typeName, name, member) {
   this.getFactoriesFor(typeName).$setindex(name, member);
 }
 FactoryMap.prototype.getFactory = function(typeName, name) {
   return this.getFactoriesFor(typeName).$index(name);
@@ skipping 16 matching lines @@
   this.end = end;
   // Initializers done
 }
 lang_Token.prototype.get$source = function() { return this.source; };
 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 ($ne(kindText, actualText)) {
-    if (actualText.length > 10) {
+  if ($notnull_bool($ne(kindText, actualText))) {
+    if ($notnull_bool(actualText.length > 10)) {
       actualText = actualText.substring(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
     return 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 (this._lineStarts == null) {
+  if ($notnull_bool(this._lineStarts == null)) {
     var starts = [0];
     var index = 0;
-    while (index < this.get$text().length) {
+    while ($notnull_bool(index < this.get$text().length)) {
       index = this.get$text().indexOf('\n', index) + 1;
-      if (index <= 0) break;
+      if ($notnull_bool(index <= 0)) break;
       starts.add(index);
     }
     starts.add(this.get$text().length + 1);
-    this._lineStarts = starts;
+    this._lineStarts = (starts && starts.is$List$int());
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = 0;
-   i < starts.length; i++) {
-    if (starts.$index(i) > position) return i - 1;
+   $notnull_bool(i < starts.length); i++) {
+    if ($notnull_bool(starts.$index(i) > position)) return i - 1;
   }
   world.internalError('bad position');
 }
 SourceFile.prototype.getColumn = function(line, position) {
-  return position - this.get$lineStarts().$index(line);
+  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(line, start);
+  var column = this.getColumn($assert_num(line), start);
   var buf = new StringBufferImpl(('' + this.filename + ':' + (line + 1) + ':' + (column + 1) + ': ' + message + ''));
-  if (includeText) {
+  if ($notnull_bool(includeText)) {
     buf.add('\n');
     var textLine;
-    if ((line + 2) < this._lineStarts.length) {
+    if ($notnull_bool((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 (; i < column; i++) {
+    for (; $notnull_bool(i < $assert_num(column)); i++) {
       buf.add(' ');
     }
-    var toColumn = Math.min(column + (end - start), textLine.length);
-    for (; i < toColumn; i++) {
+    var toColumn = Math.min($assert_num(column + (end - start)), textLine.length);
+    for (; $notnull_bool(i < toColumn); i++) {
       buf.add('^');
     }
   }
   return buf.toString();
 }
 SourceFile.prototype.compareTo = function(other) {
-  if (this.orderInLibrary != null && other.orderInLibrary != null) {
+  if ($notnull_bool(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(line, 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 ($eq(this.file, other.file)) {
+  if ($notnull_bool($eq(this.file, other.file))) {
     var d = this.start - other.start;
-    return d == 0 ? (this.end - other.end) : d;
+    return $notnull_bool(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.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote0, isMultiline0) {
   var newStack = new InterpStack(stack, quote0, isMultiline0);
-  if (stack != null) newStack.previous = stack;
+  if ($notnull_bool(stack != null)) newStack.previous = stack;
   return newStack;
 }
 // ********** 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 (this._lang_index < this._text.length) {
+  if ($notnull_bool(this._lang_index < this._text.length)) {
     return this._text.charCodeAt(this._lang_index++);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._peekChar = function() {
-  if (this._lang_index < this._text.length) {
+  if ($notnull_bool(this._lang_index < this._text.length)) {
     return this._text.charCodeAt(this._lang_index);
   }
   else {
     return 0;
   }
 }
 TokenizerBase.prototype._maybeEatChar = function(ch) {
-  if (this._lang_index < this._text.length) {
-    if (this._text.charCodeAt(this._lang_index) == ch) {
+  if ($notnull_bool(this._lang_index < this._text.length)) {
+    if ($notnull_bool(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(64/*TokenKind.ERROR*/);
+  return this._finishToken(65/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
-  while (this._lang_index < this._text.length) {
-    if (!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++))) {
+  while ($notnull_bool(this._lang_index < this._text.length)) {
+    if ($notnull_bool(!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++)))) {
       this._lang_index--;
       return this.next();
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
 TokenizerBase.prototype.finishHashBang = function() {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == 0 || ch == 10 || ch == 13) {
+    if ($notnull_bool(ch == 0 || ch == 10 || ch == 13)) {
       return this._finishToken(13/*TokenKind.HASHBANG*/);
     }
   }
 }
 TokenizerBase.prototype.finishSingleLineComment = function() {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == 0 || ch == 10 || ch == 13) {
-      if (this._skipWhitespace) {
+    if ($notnull_bool(ch == 0 || ch == 10 || ch == 13)) {
+      if ($notnull_bool(this._skipWhitespace)) {
         return this.next();
       }
       else {
-        return this._finishToken(63/*TokenKind.COMMENT*/);
+        return this._finishToken(64/*TokenKind.COMMENT*/);
       }
     }
   }
 }
 TokenizerBase.prototype.finishMultiLineComment = function() {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == 0) {
-      return this._finishToken(66/*TokenKind.INCOMPLETE_COMMENT*/);
+    if ($notnull_bool(ch == 0)) {
+      return this._finishToken(67/*TokenKind.INCOMPLETE_COMMENT*/);
     }
-    else if (ch == 42) {
-      if (this._maybeEatChar(47)) {
-        if (this._skipWhitespace) {
+    else if ($notnull_bool(ch == 42)) {
+      if ($notnull_bool(this._maybeEatChar(47))) {
+        if ($notnull_bool(this._skipWhitespace)) {
           return this.next();
         }
         else {
-          return this._finishToken(63/*TokenKind.COMMENT*/);
+          return this._finishToken(64/*TokenKind.COMMENT*/);
         }
       }
     }
   }
   return this._errorToken();
 }
 TokenizerBase.prototype.eatDigits = function() {
-  while (this._lang_index < this._text.length) {
-    if (TokenizerHelpers.isDigit(this._text.charCodeAt(this._lang_index))) {
+  while ($notnull_bool(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 (this._lang_index < this._text.length) {
-    if (TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+  while ($notnull_bool(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 (this._lang_index < this._text.length && TokenizerHelpers.isHexDigit(this._text.charCodeAt(this._lang_index))) {
+  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_NUMBER*/);
+  return this._finishToken(61/*TokenKind.HEX_INTEGER*/);
 }
 TokenizerBase.prototype.finishNumber = function() {
   this.eatDigits();
-  if (this._peekChar() == 46) {
+  if ($notnull_bool(this._peekChar() == 46)) {
     this._nextChar();
-    if (TokenizerHelpers.isDigit(this._peekChar())) {
+    if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
       this.eatDigits();
+      return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
     }
     else {
       this._lang_index--;
     }
   }
-  return this.finishNumberExtra();
+  return this.finishNumberExtra(60/*TokenKind.INTEGER*/);
 }
-TokenizerBase.prototype.finishNumberExtra = function() {
-  if (this._maybeEatChar(101) || this._maybeEatChar(69)) {
+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 (this._peekChar() != 0 && TokenizerHelpers.isIdentifierStart(this._peekChar())) {
+  if ($notnull_bool(this._peekChar() != 0 && TokenizerHelpers.isIdentifierStart(this._peekChar()))) {
     this._nextChar();
     return this._errorToken();
   }
-  return this._finishToken(60/*TokenKind.NUMBER*/);
+  return this._finishToken(kind);
 }
 TokenizerBase.prototype.finishMultilineString = function(quote) {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == 0) {
-      var kind = quote == 34 ? 67/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
+    if ($notnull_bool(ch == 0)) {
+      var kind = $notnull_bool(quote == 34) ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
       return this._finishToken(kind);
     }
-    else if (ch == quote) {
-      if (this._maybeEatChar(quote)) {
-        if (this._maybeEatChar(quote)) {
+    else if ($notnull_bool(ch == quote)) {
+      if ($notnull_bool(this._maybeEatChar(quote))) {
+        if ($notnull_bool(this._maybeEatChar(quote))) {
           return this._finishToken(58/*TokenKind.STRING*/);
         }
       }
     }
-    else if (ch == 36) {
+    else if ($notnull_bool(ch == 36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, true);
-      return this._finishToken(65/*TokenKind.INCOMPLETE_STRING*/);
+      return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if (ch == 92) {
-      if (!this.eatEscapeSequence()) {
+    else if ($notnull_bool(ch == 92)) {
+      if ($notnull_bool(!this.eatEscapeSequence())) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
-  if (this._interpStack != null) {
-    if (this._interpStack.depth == -1) {
+  if ($notnull_bool(this._interpStack != null)) {
+    if ($notnull_bool(this._interpStack.depth == -1)) {
       this._interpStack.depth = 1;
     }
     else {
+      $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 257, 16);
       ($0 = this._interpStack).depth = $0.depth + 1;
     }
   }
   return this._finishToken(6/*TokenKind.LBRACE*/);
 }
 TokenizerBase.prototype._finishCloseBrace = function() {
   var $0;
-  if (this._interpStack != null) {
+  if ($notnull_bool(this._interpStack != null)) {
     ($0 = this._interpStack).depth = $0.depth - 1;
+    $assert(this._interpStack.depth >= 0, "_interpStack.depth >= 0", "tokenizer.dart", 267, 14);
   }
   return this._finishToken(7/*TokenKind.RBRACE*/);
 }
 TokenizerBase.prototype.finishString = function(quote) {
-  if (this._maybeEatChar(quote)) {
-    if (this._maybeEatChar(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 (this._maybeEatChar(quote)) {
-    if (this._maybeEatChar(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 (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == quote) {
+    if ($notnull_bool(ch == quote)) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
-    else if (ch == 0) {
-      return this._finishToken(65/*TokenKind.INCOMPLETE_STRING*/);
+    else if ($notnull_bool(ch == 0)) {
+      return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
   }
 }
 TokenizerBase.prototype.finishMultilineRawString = function(quote) {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == 0) {
-      var kind = quote == 34 ? 67/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
+    if ($notnull_bool(ch == 0)) {
+      var kind = $notnull_bool(quote == 34) ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
       return this._finishToken(kind);
     }
-    else if (ch == quote && this._maybeEatChar(quote) && this._maybeEatChar(quote)) {
+    else if ($notnull_bool(ch == quote && this._maybeEatChar(quote) && this._maybeEatChar(quote))) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
   }
 }
 TokenizerBase.prototype.finishStringBody = function(quote) {
-  while (true) {
+  while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if (ch == quote) {
+    if ($notnull_bool(ch == quote)) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
-    else if (ch == 36) {
+    else if ($notnull_bool(ch == 36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, false);
-      return this._finishToken(65/*TokenKind.INCOMPLETE_STRING*/);
+      return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if (ch == 0) {
-      return this._finishToken(65/*TokenKind.INCOMPLETE_STRING*/);
+    else if ($notnull_bool(ch == 0)) {
+      return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
-    else if (ch == 92) {
-      if (!this.eatEscapeSequence()) {
+    else if ($notnull_bool(ch == 92)) {
+      if ($notnull_bool(!this.eatEscapeSequence())) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
       return this.maybeEatHexDigit() && this.maybeEatHexDigit();
 
     case 117:
 
-      if (this._maybeEatChar(123)) {
+      if ($notnull_bool(this._maybeEatChar(123))) {
         var start = this._lang_index;
         this.eatHexDigits();
         var chars = this._lang_index - start;
-        if (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 (this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit()) {
+        if ($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 n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
 }
 TokenizerBase.prototype.finishDot = function() {
-  if (TokenizerHelpers.isDigit(this._peekChar())) {
+  if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
     this.eatDigits();
-    return this.finishNumberExtra();
+    return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function() {
-  while (this._lang_index < this._text.length) {
-    if (!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))) {
+  while ($notnull_bool(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 (this._interpStack != null && this._interpStack.depth == -1) {
+  if ($notnull_bool(this._interpStack != null && this._interpStack.depth == -1)) {
     this._interpStack.depth = 0;
   }
-  if (kind == 69/*TokenKind.IDENTIFIER*/) {
-    return this._finishToken(69/*TokenKind.IDENTIFIER*/);
+  if ($notnull_bool(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 (this._interpStack != null && this._interpStack.depth == 0) {
+  if ($notnull_bool(this._interpStack != null && this._interpStack.depth == 0)) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
-    if (istack.isMultiline) {
+    if ($notnull_bool(istack.isMultiline)) {
       return this.finishMultilineString(istack.quote);
     }
     else {
       return this.finishStringBody(istack.quote);
     }
   }
   var ch;
   ch = this._nextChar();
   switch (ch) {
     case 0:
 
       return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 
     case 32:
     case 9:
     case 10:
     case 13:
 
       return this.finishWhitespace();
 
     case 33:
 
-      if (this._maybeEatChar(61)) {
-        if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(51/*TokenKind.NE_STRICT*/);
         }
         else {
           return this._finishToken(49/*TokenKind.NE*/);
         }
       }
       else {
         return this._finishToken(19/*TokenKind.NOT*/);
       }
 
     case 34:
 
       return this.finishString(34);
 
     case 35:
 
-      if (this._maybeEatChar(33)) {
+      if ($notnull_bool(this._maybeEatChar(33))) {
         return this.finishHashBang();
       }
       else {
         return this._finishToken(12/*TokenKind.HASH*/);
       }
 
     case 36:
 
-      if (this._maybeEatChar(34)) {
+      if ($notnull_bool(this._maybeEatChar(34))) {
         return this.finishString(34);
       }
-      else if (this._maybeEatChar(39)) {
+      else if ($notnull_bool(this._maybeEatChar(39))) {
         return this.finishString(39);
       }
       else {
         return this.finishIdentifier();
       }
 
     case 37:
 
-      if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(32/*TokenKind.ASSIGN_MOD*/);
       }
       else {
         return this._finishToken(47/*TokenKind.MOD*/);
       }
 
     case 38:
 
-      if (this._maybeEatChar(38)) {
+      if ($notnull_bool(this._maybeEatChar(38))) {
         return this._finishToken(35/*TokenKind.AND*/);
       }
-      else if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(23/*TokenKind.ASSIGN_AND*/);
       }
       else {
         return this._finishToken(38/*TokenKind.BIT_AND*/);
       }
 
     case 39:
 
       return this.finishString(39);
 
     case 40:
 
       return this._finishToken(2/*TokenKind.LPAREN*/);
 
     case 41:
 
       return this._finishToken(3/*TokenKind.RPAREN*/);
 
     case 42:
 
-      if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(29/*TokenKind.ASSIGN_MUL*/);
       }
       else {
         return this._finishToken(44/*TokenKind.MUL*/);
       }
 
     case 43:
 
-      if (this._maybeEatChar(43)) {
+      if ($notnull_bool(this._maybeEatChar(43))) {
         return this._finishToken(16/*TokenKind.INCR*/);
       }
-      else if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(27/*TokenKind.ASSIGN_ADD*/);
       }
       else {
         return this._finishToken(42/*TokenKind.ADD*/);
       }
 
     case 44:
 
       return this._finishToken(11/*TokenKind.COMMA*/);
 
     case 45:
 
-      if (this._maybeEatChar(45)) {
+      if ($notnull_bool(this._maybeEatChar(45))) {
         return this._finishToken(17/*TokenKind.DECR*/);
       }
-      else if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(28/*TokenKind.ASSIGN_SUB*/);
       }
       else {
         return this._finishToken(43/*TokenKind.SUB*/);
       }
 
     case 46:
 
-      if (this._maybeEatChar(46)) {
-        if (this._maybeEatChar(46)) {
+      if ($notnull_bool(this._maybeEatChar(46))) {
+        if ($notnull_bool(this._maybeEatChar(46))) {
           return this._finishToken(15/*TokenKind.ELLIPSIS*/);
         }
         else {
           return this._errorToken();
         }
       }
       else {
         return this.finishDot();
       }
 
     case 47:
 
-      if (this._maybeEatChar(42)) {
+      if ($notnull_bool(this._maybeEatChar(42))) {
         return this.finishMultiLineComment();
       }
-      else if (this._maybeEatChar(47)) {
+      else if ($notnull_bool(this._maybeEatChar(47))) {
         return this.finishSingleLineComment();
       }
-      else if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(30/*TokenKind.ASSIGN_DIV*/);
       }
       else {
         return this._finishToken(45/*TokenKind.DIV*/);
       }
 
     case 48:
 
-      if (this._maybeEatChar(88)) {
+      if ($notnull_bool(this._maybeEatChar(88))) {
         return this.finishHex();
       }
-      else if (this._maybeEatChar(120)) {
+      else if ($notnull_bool(this._maybeEatChar(120))) {
         return this.finishHex();
       }
       else {
         return this.finishNumber();
       }
 
     case 58:
 
       return this._finishToken(8/*TokenKind.COLON*/);
 
     case 59:
 
       return this._finishToken(10/*TokenKind.SEMICOLON*/);
 
     case 60:
 
-      if (this._maybeEatChar(60)) {
-        if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(60))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(24/*TokenKind.ASSIGN_SHL*/);
         }
         else {
           return this._finishToken(39/*TokenKind.SHL*/);
         }
       }
-      else if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(54/*TokenKind.LTE*/);
       }
       else {
         return this._finishToken(52/*TokenKind.LT*/);
       }
 
     case 61:
 
-      if (this._maybeEatChar(61)) {
-        if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(50/*TokenKind.EQ_STRICT*/);
         }
         else {
           return this._finishToken(48/*TokenKind.EQ*/);
         }
       }
-      else if (this._maybeEatChar(62)) {
+      else if ($notnull_bool(this._maybeEatChar(62))) {
         return this._finishToken(9/*TokenKind.ARROW*/);
       }
       else {
         return this._finishToken(20/*TokenKind.ASSIGN*/);
       }
 
     case 62:
 
-      if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(55/*TokenKind.GTE*/);
       }
-      else if (this._maybeEatChar(62)) {
-        if (this._maybeEatChar(61)) {
+      else if ($notnull_bool(this._maybeEatChar(62))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(25/*TokenKind.ASSIGN_SAR*/);
         }
-        else if (this._maybeEatChar(62)) {
-          if (this._maybeEatChar(61)) {
+        else if ($notnull_bool(this._maybeEatChar(62))) {
+          if ($notnull_bool(this._maybeEatChar(61))) {
             return this._finishToken(26/*TokenKind.ASSIGN_SHR*/);
           }
           else {
             return this._finishToken(41/*TokenKind.SHR*/);
           }
         }
         else {
           return this._finishToken(40/*TokenKind.SAR*/);
         }
       }
       else {
         return this._finishToken(53/*TokenKind.GT*/);
       }
 
     case 63:
 
       return this._finishToken(33/*TokenKind.CONDITIONAL*/);
 
     case 64:
 
-      if (this._maybeEatChar(34)) {
+      if ($notnull_bool(this._maybeEatChar(34))) {
         return this.finishRawString(34);
       }
-      else if (this._maybeEatChar(39)) {
+      else if ($notnull_bool(this._maybeEatChar(39))) {
         return this.finishRawString(39);
       }
       else {
         return this._errorToken();
       }
 
     case 91:
 
-      if (this._maybeEatChar(93)) {
-        if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(93))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(57/*TokenKind.SETINDEX*/);
         }
         else {
           return this._finishToken(56/*TokenKind.INDEX*/);
         }
       }
       else {
         return this._finishToken(4/*TokenKind.LBRACK*/);
       }
 
     case 93:
 
       return this._finishToken(5/*TokenKind.RBRACK*/);
 
     case 94:
 
-      if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(22/*TokenKind.ASSIGN_XOR*/);
       }
       else {
         return this._finishToken(37/*TokenKind.BIT_XOR*/);
       }
 
     case 123:
 
       return this._finishOpenBrace();
 
     case 124:
 
-      if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(61))) {
         return this._finishToken(21/*TokenKind.ASSIGN_OR*/);
       }
-      else if (this._maybeEatChar(124)) {
+      else if ($notnull_bool(this._maybeEatChar(124))) {
         return this._finishToken(34/*TokenKind.OR*/);
       }
       else {
         return this._finishToken(36/*TokenKind.BIT_OR*/);
       }
 
     case 125:
 
       return this._finishCloseBrace();
 
     case 126:
 
-      if (this._maybeEatChar(47)) {
-        if (this._maybeEatChar(61)) {
+      if ($notnull_bool(this._maybeEatChar(47))) {
+        if ($notnull_bool(this._maybeEatChar(61))) {
           return this._finishToken(31/*TokenKind.ASSIGN_TRUNCDIV*/);
         }
         else {
           return this._finishToken(46/*TokenKind.TRUNCDIV*/);
         }
       }
       else {
         return this._finishToken(18/*TokenKind.BIT_NOT*/);
       }
 
     default:
 
-      if (TokenizerHelpers.isIdentifierStart(ch)) {
+      if ($notnull_bool(TokenizerHelpers.isIdentifierStart(ch))) {
         return this.finishIdentifier();
       }
-      else if (TokenizerHelpers.isDigit(ch)) {
+      else if ($notnull_bool(TokenizerHelpers.isDigit(ch))) {
         return this.finishNumber();
       }
       else {
         return this._errorToken();
       }
 
   }
 }
 Tokenizer.prototype.getIdentifierKind = function() {
   var i0 = this._startIndex;
   switch (this._lang_index - i0) {
     case 2:
 
-      if (this._text.charCodeAt(i0) == 100) {
-        if (this._text.charCodeAt(i0 + 1) == 111) return 93/*TokenKind.DO*/;
+      if ($notnull_bool(this._text.charCodeAt(i0) == 100)) {
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) return 94/*TokenKind.DO*/;
       }
-      else if (this._text.charCodeAt(i0) == 105) {
-        if (this._text.charCodeAt(i0 + 1) == 102) {
-          return 99/*TokenKind.IF*/;
+      else if ($notnull_bool(this._text.charCodeAt(i0) == 105)) {
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 102)) {
+          return 100/*TokenKind.IF*/;
         }
-        else if (this._text.charCodeAt(i0 + 1) == 110) {
-          return 100/*TokenKind.IN*/;
+        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 110)) {
+          return 101/*TokenKind.IN*/;
         }
-        else if (this._text.charCodeAt(i0 + 1) == 115) {
-          return 101/*TokenKind.IS*/;
+        else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 115)) {
+          return 102/*TokenKind.IS*/;
         }
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 3:
 
-      if (this._text.charCodeAt(i0) == 102) {
-        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 114) return 98/*TokenKind.FOR*/;
+      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*/;
       }
-      else if (this._text.charCodeAt(i0) == 103) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 75/*TokenKind.GET*/;
+      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) == 110) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 119) return 102/*TokenKind.NEW*/;
+      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) == 115) {
-        if (this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) return 83/*TokenKind.SET*/;
+      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) == 116) {
-        if (this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121) return 110/*TokenKind.TRY*/;
+      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) == 118) {
-        if (this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114) return 111/*TokenKind.VAR*/;
+      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*/;
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 4:
 
-      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 88/*TokenKind.CASE*/;
+      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*/;
       }
-      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 94/*TokenKind.ELSE*/;
+      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) == 110) {
-        if (this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 108) return 103/*TokenKind.NULL*/;
+      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) == 116) {
-        if (this._text.charCodeAt(i0 + 1) == 104) {
-          if (this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115) return 107/*TokenKind.THIS*/;
+      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 + 1) == 114) {
-          if (this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101) return 109/*TokenKind.TRUE*/;
+        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) == 118) {
-        if (this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 100) return 112/*TokenKind.VOID*/;
+      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*/;
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 5:
 
-      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 87/*TokenKind.BREAK*/;
+      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*/;
       }
-      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 89/*TokenKind.CATCH*/;
+      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 + 1) == 108) {
-          if (this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115) return 72/*TokenKind.CLASS*/;
+        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) == 111) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116) return 90/*TokenKind.CONST*/;
+        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) == 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 95/*TokenKind.FALSE*/;
+      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 + 1) == 105) {
-          if (this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108) return 96/*TokenKind.FINAL*/;
+        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) == 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 105/*TokenKind.SUPER*/;
+      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) == 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 108/*TokenKind.THROW*/;
+      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) == 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 113/*TokenKind.WHILE*/;
+      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*/;
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 6:
 
-      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 71/*TokenKind.ASSERT*/;
+      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*/;
       }
-      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 77/*TokenKind.IMPORT*/;
+      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) == 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 80/*TokenKind.NATIVE*/;
+      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 + 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 81/*TokenKind.NEGATE*/;
+        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) == 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 104/*TokenKind.RETURN*/;
+      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) == 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 84/*TokenKind.SOURCE*/;
+      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 + 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 85/*TokenKind.STATIC*/;
+        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) == 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 106/*TokenKind.SWITCH*/;
+        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*/;
         }
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 7:
 
-      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 92/*TokenKind.DEFAULT*/;
+      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*/;
       }
-      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 73/*TokenKind.EXTENDS*/;
+      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) == 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 74/*TokenKind.FACTORY*/;
+      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 + 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 97/*TokenKind.FINALLY*/;
+        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) == 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 79/*TokenKind.LIBRARY*/;
+      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) == 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 86/*TokenKind.TYPEDEF*/;
+      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*/;
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 8:
 
-      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 70/*TokenKind.ABSTRACT*/;
+      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*/;
       }
-      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 91/*TokenKind.CONTINUE*/;
+      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) == 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 82/*TokenKind.OPERATOR*/;
+      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*/;
       }
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 9:
 
-      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 78/*TokenKind.INTERFACE*/;
-      return 69/*TokenKind.IDENTIFIER*/;
+      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*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     case 10:
 
-      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 76/*TokenKind.IMPLEMENTS*/;
-      return 69/*TokenKind.IDENTIFIER*/;
+      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*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
     default:
 
-      return 69/*TokenKind.IDENTIFIER*/;
+      return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 // ********** Code for TokenizerHelpers **************
 function TokenizerHelpers() {}
 TokenizerHelpers.isIdentifierStart = function(c) {
   return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
 }
 TokenizerHelpers.isDigit = function(c) {
   return (c >= 48 && c <= 57);
@@ skipping 240 matching lines @@
       return "[]=";
 
     case 58/*TokenKind.STRING*/:
 
       return "string";
 
     case 59/*TokenKind.STRING_PART*/:
 
       return "string part";
 
-    case 60/*TokenKind.NUMBER*/:
-
-      return "number";
-
-    case 61/*TokenKind.HEX_NUMBER*/:
-
-      return "hex number";
-
-    case 62/*TokenKind.WHITESPACE*/:
+    case 60/*TokenKind.INTEGER*/:
+
+      return "integer";
+
+    case 61/*TokenKind.HEX_INTEGER*/:
+
+      return "hex integer";
+
+    case 62/*TokenKind.DOUBLE*/:
+
+      return "double";
+
+    case 63/*TokenKind.WHITESPACE*/:
 
       return "whitespace";
 
-    case 63/*TokenKind.COMMENT*/:
+    case 64/*TokenKind.COMMENT*/:
 
       return "comment";
 
-    case 64/*TokenKind.ERROR*/:
+    case 65/*TokenKind.ERROR*/:
 
       return "error";
 
-    case 65/*TokenKind.INCOMPLETE_STRING*/:
+    case 66/*TokenKind.INCOMPLETE_STRING*/:
 
       return "incomplete string";
 
-    case 66/*TokenKind.INCOMPLETE_COMMENT*/:
+    case 67/*TokenKind.INCOMPLETE_COMMENT*/:
 
       return "incomplete comment";
 
-    case 67/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/:
+    case 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/:
 
       return "incomplete multiline string dq";
 
-    case 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/:
+    case 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/:
 
       return "incomplete multiline string sq";
 
-    case 69/*TokenKind.IDENTIFIER*/:
+    case 70/*TokenKind.IDENTIFIER*/:
 
       return "identifier";
 
-    case 70/*TokenKind.ABSTRACT*/:
+    case 71/*TokenKind.ABSTRACT*/:
 
       return "pseudo-keyword 'abstract'";
 
-    case 71/*TokenKind.ASSERT*/:
+    case 72/*TokenKind.ASSERT*/:
 
       return "pseudo-keyword 'assert'";
 
-    case 72/*TokenKind.CLASS*/:
+    case 73/*TokenKind.CLASS*/:
 
       return "pseudo-keyword 'class'";
 
-    case 73/*TokenKind.EXTENDS*/:
+    case 74/*TokenKind.EXTENDS*/:
 
       return "pseudo-keyword 'extends'";
 
-    case 74/*TokenKind.FACTORY*/:
+    case 75/*TokenKind.FACTORY*/:
 
       return "pseudo-keyword 'factory'";
 
-    case 75/*TokenKind.GET*/:
+    case 76/*TokenKind.GET*/:
 
       return "pseudo-keyword 'get'";
 
-    case 76/*TokenKind.IMPLEMENTS*/:
+    case 77/*TokenKind.IMPLEMENTS*/:
 
       return "pseudo-keyword 'implements'";
 
-    case 77/*TokenKind.IMPORT*/:
+    case 78/*TokenKind.IMPORT*/:
 
       return "pseudo-keyword 'import'";
 
-    case 78/*TokenKind.INTERFACE*/:
+    case 79/*TokenKind.INTERFACE*/:
 
       return "pseudo-keyword 'interface'";
 
-    case 79/*TokenKind.LIBRARY*/:
+    case 80/*TokenKind.LIBRARY*/:
 
       return "pseudo-keyword 'library'";
 
-    case 80/*TokenKind.NATIVE*/:
+    case 81/*TokenKind.NATIVE*/:
 
       return "pseudo-keyword 'native'";
 
-    case 81/*TokenKind.NEGATE*/:
+    case 82/*TokenKind.NEGATE*/:
 
       return "pseudo-keyword 'negate'";
 
-    case 82/*TokenKind.OPERATOR*/:
+    case 83/*TokenKind.OPERATOR*/:
 
       return "pseudo-keyword 'operator'";
 
-    case 83/*TokenKind.SET*/:
+    case 84/*TokenKind.SET*/:
 
       return "pseudo-keyword 'set'";
 
-    case 84/*TokenKind.SOURCE*/:
+    case 85/*TokenKind.SOURCE*/:
 
       return "pseudo-keyword 'source'";
 
-    case 85/*TokenKind.STATIC*/:
+    case 86/*TokenKind.STATIC*/:
 
       return "pseudo-keyword 'static'";
 
-    case 86/*TokenKind.TYPEDEF*/:
+    case 87/*TokenKind.TYPEDEF*/:
 
       return "pseudo-keyword 'typedef'";
 
-    case 87/*TokenKind.BREAK*/:
+    case 88/*TokenKind.BREAK*/:
 
       return "keyword 'break'";
 
-    case 88/*TokenKind.CASE*/:
+    case 89/*TokenKind.CASE*/:
 
       return "keyword 'case'";
 
-    case 89/*TokenKind.CATCH*/:
+    case 90/*TokenKind.CATCH*/:
 
       return "keyword 'catch'";
 
-    case 90/*TokenKind.CONST*/:
+    case 91/*TokenKind.CONST*/:
 
       return "keyword 'const'";
 
-    case 91/*TokenKind.CONTINUE*/:
+    case 92/*TokenKind.CONTINUE*/:
 
       return "keyword 'continue'";
 
-    case 92/*TokenKind.DEFAULT*/:
+    case 93/*TokenKind.DEFAULT*/:
 
       return "keyword 'default'";
 
-    case 93/*TokenKind.DO*/:
+    case 94/*TokenKind.DO*/:
 
       return "keyword 'do'";
 
-    case 94/*TokenKind.ELSE*/:
+    case 95/*TokenKind.ELSE*/:
 
       return "keyword 'else'";
 
-    case 95/*TokenKind.FALSE*/:
+    case 96/*TokenKind.FALSE*/:
 
       return "keyword 'false'";
 
-    case 96/*TokenKind.FINAL*/:
+    case 97/*TokenKind.FINAL*/:
 
       return "keyword 'final'";
 
-    case 97/*TokenKind.FINALLY*/:
+    case 98/*TokenKind.FINALLY*/:
 
       return "keyword 'finally'";
 
-    case 98/*TokenKind.FOR*/:
+    case 99/*TokenKind.FOR*/:
 
       return "keyword 'for'";
 
-    case 99/*TokenKind.IF*/:
+    case 100/*TokenKind.IF*/:
 
       return "keyword 'if'";
 
-    case 100/*TokenKind.IN*/:
+    case 101/*TokenKind.IN*/:
 
       return "keyword 'in'";
 
-    case 101/*TokenKind.IS*/:
+    case 102/*TokenKind.IS*/:
 
       return "keyword 'is'";
 
-    case 102/*TokenKind.NEW*/:
+    case 103/*TokenKind.NEW*/:
 
       return "keyword 'new'";
 
-    case 103/*TokenKind.NULL*/:
+    case 104/*TokenKind.NULL*/:
 
       return "keyword 'null'";
 
-    case 104/*TokenKind.RETURN*/:
+    case 105/*TokenKind.RETURN*/:
 
       return "keyword 'return'";
 
-    case 105/*TokenKind.SUPER*/:
+    case 106/*TokenKind.SUPER*/:
 
       return "keyword 'super'";
 
-    case 106/*TokenKind.SWITCH*/:
+    case 107/*TokenKind.SWITCH*/:
 
       return "keyword 'switch'";
 
-    case 107/*TokenKind.THIS*/:
+    case 108/*TokenKind.THIS*/:
 
       return "keyword 'this'";
 
-    case 108/*TokenKind.THROW*/:
+    case 109/*TokenKind.THROW*/:
 
       return "keyword 'throw'";
 
-    case 109/*TokenKind.TRUE*/:
+    case 110/*TokenKind.TRUE*/:
 
       return "keyword 'true'";
 
-    case 110/*TokenKind.TRY*/:
+    case 111/*TokenKind.TRY*/:
 
       return "keyword 'try'";
 
-    case 111/*TokenKind.VAR*/:
+    case 112/*TokenKind.VAR*/:
 
       return "keyword 'var'";
 
-    case 112/*TokenKind.VOID*/:
+    case 113/*TokenKind.VOID*/:
 
       return "keyword 'void'";
 
-    case 113/*TokenKind.WHILE*/:
+    case 114/*TokenKind.WHILE*/:
 
       return "keyword 'while'";
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
-  return kind >= 69/*TokenKind.IDENTIFIER*/ && kind < 87/*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 127 matching lines @@
       return 10;
 
     case 54/*TokenKind.LTE*/:
 
       return 10;
 
     case 55/*TokenKind.GTE*/:
 
       return 10;
 
-    case 101/*TokenKind.IS*/:
+    case 102/*TokenKind.IS*/:
 
       return 10;
 
     default:
 
       return -1;
 
   }
 }
 TokenKind.rawOperatorFromMethod = function(name) {
@@ skipping 162 matching lines @@
 
       return '\$index';
 
     case 57/*TokenKind.SETINDEX*/:
 
       return '\$setindex';
 
   }
 }
 TokenKind.kindFromAssign = function(kind) {
-  if (kind == 20/*TokenKind.ASSIGN*/) return 0;
-  if (kind > 20/*TokenKind.ASSIGN*/ && kind <= 32/*TokenKind.ASSIGN_MOD*/) {
+  if ($notnull_bool(kind == 20/*TokenKind.ASSIGN*/)) return 0;
+  if ($notnull_bool(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, startOffset) {
   this.source = source;
   this.diet = diet;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
 lang_Parser.prototype.get$source = function() { return this.source; };
 lang_Parser.prototype.isPrematureEndOfFile = function() {
-  if (this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
+  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 (this._peekToken.kind == kind) {
+  if ($notnull_bool(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 (!this._maybeEat(kind)) {
+  if ($notnull_bool(!this._maybeEat(kind))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 lang_Parser.prototype._eatSemicolon = function() {
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 lang_Parser.prototype._errorExpected = function(expected) {
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
-  this._lang_error(message, tok.get$span());
+  this._lang_error($assert_String(message), tok.get$span());
 }
 lang_Parser.prototype._lang_error = function(message, location) {
-  if (location == null) {
+  if ($notnull_bool(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 (true) {
+  while ($notnull_bool(true)) {
     var tok = this._lang_next();
-    if (tok.kind == 6/*TokenKind.LBRACE*/) {
+    if ($notnull_bool(tok.kind == 6/*TokenKind.LBRACE*/)) {
       depth += 1;
     }
-    else if (tok.kind == 7/*TokenKind.RBRACE*/) {
+    else if ($notnull_bool(tok.kind == 7/*TokenKind.RBRACE*/)) {
       depth -= 1;
-      if (depth == 0) return;
+      if ($notnull_bool(depth == 0)) return;
     }
-    else if (tok.kind == 1/*TokenKind.END_OF_FILE*/) {
+    else if ($notnull_bool(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 (this._peekKind(12/*TokenKind.HASH*/)) {
+  while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add(this.directive());
   }
-  while (!this._maybeEat(1/*TokenKind.END_OF_FILE*/)) {
+  while ($notnull_bool(!this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     ret.add(this.topLevelDefinition());
   }
   return ret;
 }
 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();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.topLevelDefinition = function() {
   switch (this._peek()) {
-    case 72/*TokenKind.CLASS*/:
+    case 73/*TokenKind.CLASS*/:
 
-      return this.classDefinition(72/*TokenKind.CLASS*/);
+      return this.classDefinition(73/*TokenKind.CLASS*/);
 
-    case 78/*TokenKind.INTERFACE*/:
+    case 79/*TokenKind.INTERFACE*/:
 
-      return this.classDefinition(78/*TokenKind.INTERFACE*/);
+      return this.classDefinition(79/*TokenKind.INTERFACE*/);
 
-    case 86/*TokenKind.TYPEDEF*/:
+    case 87/*TokenKind.TYPEDEF*/:
 
       return this.functionTypeAlias();
 
     default:
 
       return this.declaration(true);
 
   }
 }
 lang_Parser.prototype.classDefinition = function(kind) {
   var start = this._peekToken.start;
   this._eat(kind);
   var name = this.identifier();
   var typeParams = null;
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var _extends = null;
-  if (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
+  if ($notnull_bool(this._maybeEat(74/*TokenKind.EXTENDS*/))) {
     _extends = this.typeList();
   }
   var _implements = null;
-  if (this._maybeEat(76/*TokenKind.IMPLEMENTS*/)) {
+  if ($notnull_bool(this._maybeEat(77/*TokenKind.IMPLEMENTS*/))) {
     _implements = this.typeList();
   }
   var _native = null;
-  if (this._maybeEat(80/*TokenKind.NATIVE*/)) {
+  if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
     _native = this.maybeStringLiteral();
   }
   var _factory = null;
-  if (this._maybeEat(74/*TokenKind.FACTORY*/)) {
+  if ($notnull_bool(this._maybeEat(75/*TokenKind.FACTORY*/))) {
     _factory = this.type(0);
   }
   var body = [];
-  if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
-    while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
-      if (this.isPrematureEndOfFile()) break;
+  if ($notnull_bool(this._maybeEat(6/*TokenKind.LBRACE*/))) {
+    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 == 72/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
+  return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
 lang_Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
-  this._eat(86/*TokenKind.TYPEDEF*/);
+  this._eat(87/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
   var func = new FunctionDefinition(null, di.type, di.get$name(), formals, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
 lang_Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add(this.expression());
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
+  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 (this._maybeEat(9/*TokenKind.ARROW*/)) {
+  if ($notnull_bool(this._maybeEat(9/*TokenKind.ARROW*/))) {
     var expr = this.expression();
-    if (!inExpression) {
+    if ($notnull_bool(!inExpression)) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
-  else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
-    if (this.diet) {
+  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 (!inExpression) {
-    if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  else if ($notnull_bool(!inExpression)) {
+    if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
       return null;
     }
-    else if (this._maybeEat(80/*TokenKind.NATIVE*/)) {
+    else if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
       var nativeBody = this.maybeStringLiteral();
-      if (this._peekKind(10/*TokenKind.SEMICOLON*/)) {
+      if ($notnull_bool(this._peekKind(10/*TokenKind.SEMICOLON*/))) {
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
         return this.functionBody(inExpression);
       }
     }
   }
   this._lang_error('Expected function body (neither { nor => found)');
 }
 lang_Parser.prototype.finishField = function(start, modifiers, type0, name, value) {
   var names = [name];
   var values = [value];
-  while (this._maybeEat(11/*TokenKind.COMMA*/)) {
+  while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     names.add(this.identifier());
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       values.add(this.expression());
     }
     else {
       values.add(null);
     }
   }
   this._eatSemicolon();
-  return new VariableDefinition(modifiers, type0, names, values, this._makeSpan(start));
+  return new VariableDefinition(modifiers, type0, names, values, this._makeSpan($assert_num(start)));
 }
 lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
-      if (this._maybeEat(8/*TokenKind.COLON*/)) {
+      if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
-      if (di.get$name() == null) {
+      if ($notnull_bool(di.get$name() == null)) {
         di.name = di.type.get$name();
       }
-      return new FunctionDefinition(modifiers, di.type, di.get$name(), formals, inits, body, this._makeSpan(start));
+      return new FunctionDefinition(modifiers, di.type, di.get$name(), formals, inits, body, this._makeSpan($assert_num(start)));
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
       return this.finishField(start, modifiers, di.type, di.get$name(), value);
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.finishField(start, modifiers, di.type, di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
 lang_Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
-  if (this._peekKind(74/*TokenKind.FACTORY*/)) {
+  if ($notnull_bool(this._peekKind(75/*TokenKind.FACTORY*/))) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
 lang_Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
-  while (this._maybeEat(14/*TokenKind.DOT*/)) {
+  while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     names.add(this.identifier());
   }
   var typeParams = null;
-  if (this._peekKind(52/*TokenKind.LT*/)) {
+  if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type0 = null;
-  if (this._maybeEat(14/*TokenKind.DOT*/)) {
+  if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
-  else if (typeParams == null) {
-    if (names.length > 1) {
+  else if ($notnull_bool(typeParams == null)) {
+    if ($notnull_bool(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 (names.length > 1) {
+  if ($notnull_bool(names.length > 1)) {
     this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type0 = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type0, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 lang_Parser.prototype.statement = function() {
   switch (this._peek()) {
-    case 87/*TokenKind.BREAK*/:
+    case 88/*TokenKind.BREAK*/:
 
       return this.breakStatement();
 
-    case 91/*TokenKind.CONTINUE*/:
+    case 92/*TokenKind.CONTINUE*/:
 
       return this.continueStatement();
 
-    case 104/*TokenKind.RETURN*/:
+    case 105/*TokenKind.RETURN*/:
 
       return this.returnStatement();
 
-    case 108/*TokenKind.THROW*/:
+    case 109/*TokenKind.THROW*/:
 
       return this.throwStatement();
 
-    case 71/*TokenKind.ASSERT*/:
+    case 72/*TokenKind.ASSERT*/:
 
       return this.assertStatement();
 
-    case 113/*TokenKind.WHILE*/:
+    case 114/*TokenKind.WHILE*/:
 
       return this.whileStatement();
 
-    case 93/*TokenKind.DO*/:
+    case 94/*TokenKind.DO*/:
 
       return this.doStatement();
 
-    case 98/*TokenKind.FOR*/:
+    case 99/*TokenKind.FOR*/:
 
       return this.forStatement();
 
-    case 99/*TokenKind.IF*/:
+    case 100/*TokenKind.IF*/:
 
       return this.ifStatement();
 
-    case 106/*TokenKind.SWITCH*/:
+    case 107/*TokenKind.SWITCH*/:
 
       return this.switchStatement();
 
-    case 110/*TokenKind.TRY*/:
+    case 111/*TokenKind.TRY*/:
 
       return this.tryStatement();
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.block();
 
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.emptyStatement();
 
-    case 96/*TokenKind.FINAL*/:
+    case 97/*TokenKind.FINAL*/:
 
       return this.declaration(false);
 
-    case 111/*TokenKind.VAR*/:
+    case 112/*TokenKind.VAR*/:
 
       return this.declaration(false);
 
     default:
 
       return this.finishExpressionAsStatement(this.expression());
 
   }
 }
 lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
   var start = expr.get$span().start;
-  if (this._maybeEat(8/*TokenKind.COLON*/)) {
+  if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
-  if ((expr instanceof LambdaExpression)) {
-    if (!(expr.func.body instanceof BlockStatement)) {
+  if ($notnull_bool((expr instanceof LambdaExpression))) {
+    if ($notnull_bool(!(expr.func.body instanceof BlockStatement))) {
       this._eatSemicolon();
       expr.func.span = this._makeSpan(start);
     }
     return expr.func;
   }
-  else if ((expr instanceof DeclaredIdentifier)) {
+  else if ($notnull_bool((expr instanceof DeclaredIdentifier))) {
     var value = null;
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
     return this.finishField(start, null, expr.type, expr.get$name(), value);
   }
-  else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier))) {
+  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
     var di = expr.x;
     return this.finishField(start, null, di.type, di.name, expr.y);
   }
-  else if (this._isBin(expr, 52/*TokenKind.LT*/) && this._maybeEat(11/*TokenKind.COMMA*/)) {
+  else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/) && this._maybeEat(11/*TokenKind.COMMA*/))) {
     var baseType = this._makeType(expr.x);
     var typeArgs = [this._makeType(expr.y)];
-    var gt = this._finishTypeArguments(baseType, 0, typeArgs);
+    var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
     var name = this.identifier();
     var value = null;
-    if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
+    if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
     return this.finishField(expr.get$span().start, null, gt, name, value);
   }
   else {
     this._eatSemicolon();
     return new lang_ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
   }
 }
 lang_Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return ret;
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
-  while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
-    if (this.isPrematureEndOfFile()) break;
+  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));
 }
 lang_Parser.prototype.ifStatement = function() {
   var start = this._peekToken.start;
-  this._eat(99/*TokenKind.IF*/);
+  this._eat(100/*TokenKind.IF*/);
   var test = this.testCondition();
   var trueBranch = this.statement();
   var falseBranch = null;
-  if (this._maybeEat(94/*TokenKind.ELSE*/)) {
+  if ($notnull_bool(this._maybeEat(95/*TokenKind.ELSE*/))) {
     falseBranch = this.statement();
   }
   return new IfStatement(test, trueBranch, falseBranch, this._makeSpan(start));
 }
 lang_Parser.prototype.whileStatement = function() {
   var start = this._peekToken.start;
-  this._eat(113/*TokenKind.WHILE*/);
+  this._eat(114/*TokenKind.WHILE*/);
   var test = this.testCondition();
   var body = this.statement();
   return new WhileStatement(test, body, this._makeSpan(start));
 }
 lang_Parser.prototype.doStatement = function() {
   var start = this._peekToken.start;
-  this._eat(93/*TokenKind.DO*/);
+  this._eat(94/*TokenKind.DO*/);
   var body = this.statement();
-  this._eat(113/*TokenKind.WHILE*/);
+  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(98/*TokenKind.FOR*/);
+  this._eat(99/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
-  if ((init instanceof ForInStatement)) {
+  if ($notnull_bool((init instanceof ForInStatement))) {
     return init;
   }
   var test = null;
-  if (!this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if ($notnull_bool(!this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
-  if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
+  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
     step.add(this.expression());
-    while (this._maybeEat(11/*TokenKind.COMMA*/)) {
+    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) {
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  var $0;
+  if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     return null;
   }
   else {
     var init = this.expression();
-    if (this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/)) {
+    if ($notnull_bool(this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/))) {
       this._eat(11/*TokenKind.COMMA*/);
       var baseType = this._makeType(init.x);
       var typeArgs = [this._makeType(init.y)];
-      var gt = this._finishTypeArguments(baseType, 0, typeArgs);
+      var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
       var name = this.identifier();
       init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().start));
     }
-    if (this._maybeEat(100/*TokenKind.IN*/)) {
-      return this._finishForIn(start, this._makeDeclaredIdentifier(init));
+    if ($notnull_bool(this._maybeEat(101/*TokenKind.IN*/))) {
+      return this._finishForIn(start, (($0 = this._makeDeclaredIdentifier(init)) && $0.is$DeclaredIdentifier()));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
 lang_Parser.prototype._finishForIn = function(start, di) {
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.statement();
   return new ForInStatement(di, expr, body, this._makeSpan(start));
 }
 lang_Parser.prototype.tryStatement = function() {
   var start = this._peekToken.start;
-  this._eat(110/*TokenKind.TRY*/);
+  this._eat(111/*TokenKind.TRY*/);
   var body = this.block();
   var catches = [];
-  while (this._peekKind(89/*TokenKind.CATCH*/)) {
+  while ($notnull_bool(this._peekKind(90/*TokenKind.CATCH*/))) {
     catches.add(this.catchNode());
   }
   var finallyBlock = null;
-  if (this._maybeEat(97/*TokenKind.FINALLY*/)) {
+  if ($notnull_bool(this._maybeEat(98/*TokenKind.FINALLY*/))) {
     finallyBlock = this.block();
   }
   return new TryStatement(body, catches, finallyBlock, this._makeSpan(start));
 }
 lang_Parser.prototype.catchNode = function() {
   var start = this._peekToken.start;
-  this._eat(89/*TokenKind.CATCH*/);
+  this._eat(90/*TokenKind.CATCH*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var exc = this.declaredIdentifier(false);
   var trace = null;
-  if (this._maybeEat(11/*TokenKind.COMMA*/)) {
+  if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
     trace = this.declaredIdentifier(false);
   }
   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(106/*TokenKind.SWITCH*/);
+  this._eat(107/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while (!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 $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 88/*TokenKind.CASE*/) || $eq(kind, 92/*TokenKind.DEFAULT*/);
+  return $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 (this._peekIdentifier()) {
+  if ($notnull_bool(this._peekIdentifier())) {
     label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
   }
   var cases = [];
-  while (true) {
-    if (this._maybeEat(88/*TokenKind.CASE*/)) {
+  while ($notnull_bool(true)) {
+    if ($notnull_bool(this._maybeEat(89/*TokenKind.CASE*/))) {
       cases.add(this.expression());
       this._eat(8/*TokenKind.COLON*/);
     }
-    else if (this._maybeEat(92/*TokenKind.DEFAULT*/)) {
+    else if ($notnull_bool(this._maybeEat(93/*TokenKind.DEFAULT*/))) {
       cases.add(null);
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
-  if (cases.length == 0) {
+  if ($notnull_bool(cases.length == 0)) {
     this._lang_error('case or default');
   }
   var stmts = [];
-  while (!this._peekCaseEnd()) {
-    if (this.isPrematureEndOfFile()) break;
+  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(104/*TokenKind.RETURN*/);
+  this._eat(105/*TokenKind.RETURN*/);
   var expr;
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ReturnStatement(expr, this._makeSpan(start));
 }
 lang_Parser.prototype.throwStatement = function() {
   var start = this._peekToken.start;
-  this._eat(108/*TokenKind.THROW*/);
+  this._eat(109/*TokenKind.THROW*/);
   var expr;
-  if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
+  if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     expr = null;
   }
   else {
     expr = this.expression();
     this._eatSemicolon();
   }
   return new ThrowStatement(expr, this._makeSpan(start));
 }
 lang_Parser.prototype.assertStatement = function() {
   var start = this._peekToken.start;
-  this._eat(71/*TokenKind.ASSERT*/);
+  this._eat(72/*TokenKind.ASSERT*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var expr = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   this._eatSemicolon();
   return new AssertStatement(expr, this._makeSpan(start));
 }
 lang_Parser.prototype.breakStatement = function() {
   var start = this._peekToken.start;
-  this._eat(87/*TokenKind.BREAK*/);
+  this._eat(88/*TokenKind.BREAK*/);
   var name = null;
-  if (this._peekIdentifier()) {
+  if ($notnull_bool(this._peekIdentifier())) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new BreakStatement(name, this._makeSpan(start));
 }
 lang_Parser.prototype.continueStatement = function() {
   var start = this._peekToken.start;
-  this._eat(91/*TokenKind.CONTINUE*/);
+  this._eat(92/*TokenKind.CONTINUE*/);
   var name = null;
-  if (this._peekIdentifier()) {
+  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 ((expr instanceof VarExpression)) {
+  if ($notnull_bool((expr instanceof VarExpression))) {
     return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
   }
-  else if ((expr instanceof DotExpression)) {
+  else if ($notnull_bool((expr instanceof DotExpression))) {
     var type0 = this._makeType(expr.self);
-    if (type0.names == null) {
+    if ($notnull_bool(type0.names == null)) {
       type0.names = [expr.get$name()];
     }
     else {
       type0.names.add(expr.get$name());
     }
     type0.span = expr.get$span();
     return type0;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
 lang_Parser.prototype.infixExpression = function(precedence) {
-  return this.finishInfixExpression(this.unaryExpression(), precedence);
+  var $0;
+  return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$lang_Expression()), precedence);
 }
 lang_Parser.prototype._finishDeclaredId = function(type0) {
   var name = this.identifier();
   return this.finishPostfixExpression(new DeclaredIdentifier(type0, name, this._makeSpan(type0.get$span().start)));
 }
 lang_Parser.prototype._fixAsType = function(x) {
-  if (this._maybeEat(53/*TokenKind.GT*/)) {
+  $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 771, 12);
+  if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     var type0 = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type0);
   }
   else {
+    $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 782, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
-    var firstParam = this.addTypeArguments(paramBase, 1);
+    var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type0;
-    if (firstParam.depth <= 0) {
+    if ($notnull_bool(firstParam.depth <= 0)) {
       type0 = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
-    else if (this._maybeEat(11/*TokenKind.COMMA*/)) {
-      type0 = this._finishTypeArguments(base, 0, [firstParam]);
+    else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
+      type0 = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
       type0 = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type0);
   }
 }
 lang_Parser.prototype.finishInfixExpression = function(x, precedence) {
-  while (true) {
+  while ($notnull_bool(true)) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
-    if (prec >= precedence) {
-      if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
-        if (this._isBin(x, 52/*TokenKind.LT*/)) {
-          return this._fixAsType(x);
+    if ($notnull_bool(prec >= precedence)) {
+      if ($notnull_bool(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 (op.kind == 101/*TokenKind.IS*/) {
+      if ($notnull_bool(op.kind == 102/*TokenKind.IS*/)) {
         var isTrue = !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($eq(prec, 2) ? prec : prec + 1);
-      if (op.kind == 33/*TokenKind.CONDITIONAL*/) {
+      var y = this.infixExpression($assert_num($notnull_bool($eq(prec, 2)) ? prec : prec + 1));
+      if ($notnull_bool(op.kind == 33/*TokenKind.CONDITIONAL*/)) {
         this._eat(8/*TokenKind.COLON*/);
-        var z = this.infixExpression(prec + 1);
+        var z = this.infixExpression($assert_num(prec + 1));
         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 11 matching lines @@
       return true;
 
     default:
 
       return false;
 
   }
 }
 lang_Parser.prototype.unaryExpression = function() {
   var start = this._peekToken.start;
-  if (this._isPrefixUnaryOperator(this._peek())) {
+  if ($notnull_bool(this._isPrefixUnaryOperator(this._peek()))) {
     var tok = this._lang_next();
     var expr = this.unaryExpression();
     return new UnaryExpression(tok, expr, this._makeSpan(start));
   }
   return this.finishPostfixExpression(this.primary());
 }
 lang_Parser.prototype.argument = function() {
   var start = this._peekToken.start;
   var expr;
   var label = null;
-  if (this._maybeEat(15/*TokenKind.ELLIPSIS*/)) {
+  if ($notnull_bool(this._maybeEat(15/*TokenKind.ELLIPSIS*/))) {
     label = new lang_Identifier('...', this._makeSpan(start));
   }
   expr = this.expression();
-  if (label == null && this._maybeEat(8/*TokenKind.COLON*/)) {
+  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 (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
+  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
     do {
       args.add(this.argument());
     }
-    while (this._maybeEat(11/*TokenKind.COMMA*/))
+    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);
 }
 lang_Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
@@ skipping 16 matching lines @@
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       var tok = this._lang_next();
       return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().start));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
-      if (this._inInitializers) return expr;
+      if ($notnull_bool(this._inInitializers)) return expr;
       var body = this.functionBody(true);
       return this._makeFunction(expr, body);
 
     default:
 
-      if (this._peekIdentifier()) {
+      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 (expr instanceof BinaryExpression) && expr.op.kind == kind;
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.boolType);
 }
-lang_Parser.prototype._numTypeRef = function(span) {
-  return new TypeReference(span, world.numType);
+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);
 }
 lang_Parser.prototype.primary = function() {
   var start = this._peekToken.start;
   switch (this._peek()) {
-    case 107/*TokenKind.THIS*/:
+    case 108/*TokenKind.THIS*/:
 
-      this._eat(107/*TokenKind.THIS*/);
+      this._eat(108/*TokenKind.THIS*/);
       return new ThisExpression(this._makeSpan(start));
 
-    case 105/*TokenKind.SUPER*/:
+    case 106/*TokenKind.SUPER*/:
 
-      this._eat(105/*TokenKind.SUPER*/);
+      this._eat(106/*TokenKind.SUPER*/);
       return new SuperExpression(this._makeSpan(start));
 
-    case 90/*TokenKind.CONST*/:
+    case 91/*TokenKind.CONST*/:
 
-      this._eat(90/*TokenKind.CONST*/);
-      if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
+      this._eat(91/*TokenKind.CONST*/);
+      if ($notnull_bool(this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/))) {
         return this.finishListLiteral(start, true, null);
       }
-      else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
+      else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
         return this.finishMapLiteral(start, true, null);
       }
-      else if (this._peekKind(52/*TokenKind.LT*/)) {
+      else if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
         return this.finishTypedLiteral(start, true);
       }
       else {
         return this.finishNewExpression(start, true);
       }
 
-    case 102/*TokenKind.NEW*/:
+    case 103/*TokenKind.NEW*/:
 
-      this._eat(102/*TokenKind.NEW*/);
+      this._eat(103/*TokenKind.NEW*/);
       return this.finishNewExpression(start, false);
 
     case 2/*TokenKind.LPAREN*/:
 
       return this._parenOrLambda();
 
     case 4/*TokenKind.LBRACK*/:
     case 56/*TokenKind.INDEX*/:
 
       return this.finishListLiteral(start, false, null);
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.finishMapLiteral(start, false, null);
 
-    case 103/*TokenKind.NULL*/:
+    case 104/*TokenKind.NULL*/:
 
-      this._eat(103/*TokenKind.NULL*/);
+      this._eat(104/*TokenKind.NULL*/);
       return new NullExpression(this._makeSpan(start));
 
-    case 109/*TokenKind.TRUE*/:
+    case 110/*TokenKind.TRUE*/:
 
-      this._eat(109/*TokenKind.TRUE*/);
+      this._eat(110/*TokenKind.TRUE*/);
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
-    case 95/*TokenKind.FALSE*/:
+    case 96/*TokenKind.FALSE*/:
 
-      this._eat(95/*TokenKind.FALSE*/);
+      this._eat(96/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
-    case 61/*TokenKind.HEX_NUMBER*/:
+    case 61/*TokenKind.HEX_INTEGER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
-    case 60/*TokenKind.NUMBER*/:
+    case 60/*TokenKind.INTEGER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(Math.parseDouble(t.get$text()), this._numTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(Math.parseInt(t.get$text()), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+
+    case 62/*TokenKind.DOUBLE*/:
+
+      var t = this._lang_next();
+      return new LiteralExpression(Math.parseDouble(t.get$text()), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
 
-    case 65/*TokenKind.INCOMPLETE_STRING*/:
+    case 66/*TokenKind.INCOMPLETE_STRING*/:
 
       return this.stringInterpolation();
 
     case 52/*TokenKind.LT*/:
 
       return this.finishTypedLiteral(start, false);
 
-    case 112/*TokenKind.VOID*/:
-    case 111/*TokenKind.VAR*/:
-    case 96/*TokenKind.FINAL*/:
+    case 113/*TokenKind.VOID*/:
+    case 112/*TokenKind.VAR*/:
+    case 97/*TokenKind.FINAL*/:
 
       return this.declaredIdentifier(false);
 
     default:
 
-      if (!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;
-  while (this._peekKind(65/*TokenKind.INCOMPLETE_STRING*/)) {
+  while ($notnull_bool(this._peekKind(66/*TokenKind.INCOMPLETE_STRING*/))) {
     var token = this._lang_next();
     var text = token.get$text();
-    if (startQuote == null) {
-      if (isMultilineString(text)) {
+    if ($notnull_bool(startQuote == null)) {
+      if ($notnull_bool(isMultilineString($assert_String(text)))) {
         endQuote = text.substring(0, 3);
         startQuote = endQuote + '\n';
       }
       else {
         startQuote = endQuote = text.$index(0);
       }
       text = text.substring(0, text.length - 1) + endQuote;
     }
     else {
       text = startQuote + text.substring(0, text.length - 1) + endQuote;
     }
-    lits.add(this.makeStringLiteral(text, token.get$span()));
-    if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
+    lits.add(this.makeStringLiteral($assert_String(text), token.get$span()));
+    if ($notnull_bool(this._maybeEat(6/*TokenKind.LBRACE*/))) {
       lits.add(this.expression());
       this._eat(7/*TokenKind.RBRACE*/);
     }
     else {
       var id = this.identifier();
       lits.add(new VarExpression(id, id.get$span()));
     }
   }
   var tok = this._lang_next();
-  if (tok.kind != 58/*TokenKind.STRING*/) {
+  if ($notnull_bool(tok.kind != 58/*TokenKind.STRING*/)) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
-  lits.add(this.makeStringLiteral(text, tok.get$span()));
+  lits.add(this.makeStringLiteral($assert_String(text), tok.get$span()));
   var span = this._makeSpan(start);
-  return new LiteralExpression(lits, this._stringTypeRef(span), '\$\$\$', span);
+  return new LiteralExpression(lits, this._stringTypeRef((span && span.is$SourceSpan())), '\$\$\$', (span && span.is$SourceSpan()));
 }
 lang_Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
 lang_Parser.prototype.stringLiteralExpr = function() {
   var token = this._lang_next();
   return this.makeStringLiteral(token.get$text(), token.get$span());
 }
 lang_Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
-  if ($eq(kind, 58/*TokenKind.STRING*/)) {
+  if ($notnull_bool($eq(kind, 58/*TokenKind.STRING*/))) {
     return parseStringLiteral(this._lang_next().get$text());
   }
-  else if ($eq(kind, 59/*TokenKind.STRING_PART*/)) {
+  else if ($notnull_bool($eq(kind, 59/*TokenKind.STRING_PART*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
-  else if ($eq(kind, 65/*TokenKind.INCOMPLETE_STRING*/)) {
+  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 (!this._inInitializers && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))) {
+  if ($notnull_bool(!this._inInitializers && (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 (args.length == 1) {
+    if ($notnull_bool(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(type0) {
   return type0.get$name();
 }
 lang_Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
       this._lang_error('rest no longer supported', this._previousToken.get$span());
-      name = this.identifier().get$name();
+      name = $assert_String(this.identifier().get$name());
       break;
 
-    case 107/*TokenKind.THIS*/:
+    case 108/*TokenKind.THIS*/:
 
-      this._eat(107/*TokenKind.THIS*/);
+      this._eat(108/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name() + '');
       break;
 
-    case 75/*TokenKind.GET*/:
+    case 76/*TokenKind.GET*/:
 
-      if (!includeOperators) return null;
-      this._eat(75/*TokenKind.GET*/);
-      if (this._peekIdentifier()) {
+      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 83/*TokenKind.SET*/:
+    case 84/*TokenKind.SET*/:
 
-      if (!includeOperators) return null;
-      this._eat(83/*TokenKind.SET*/);
-      if (this._peekIdentifier()) {
+      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 82/*TokenKind.OPERATOR*/:
+    case 83/*TokenKind.OPERATOR*/:
 
-      if (!includeOperators) return null;
-      this._eat(82/*TokenKind.OPERATOR*/);
+      if ($notnull_bool(!includeOperators)) return null;
+      this._eat(83/*TokenKind.OPERATOR*/);
       var kind = this._peek();
-      if ($eq(kind, 81/*TokenKind.NEGATE*/)) {
+      if ($notnull_bool($eq(kind, 82/*TokenKind.NEGATE*/))) {
         name = '\$negate';
         this._lang_next();
       }
       else {
-        name = TokenKind.binaryMethodName(kind);
-        if (name == null) {
+        name = TokenKind.binaryMethodName($assert_num(kind));
+        if ($notnull_bool(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 (name == null) {
+  if ($notnull_bool(name == null)) {
     myType = this.type(0);
     name = this._specialIdentifier(includeOperators);
-    if (name == null) {
-      if (this._peekIdentifier()) {
+    if ($notnull_bool(name == null)) {
+      if ($notnull_bool(this._peekIdentifier())) {
         name = this.identifier();
       }
-      else if ((myType instanceof NameTypeReference) && myType.names == null) {
+      else if ($notnull_bool((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 (c >= 48 && c <= 57) {
+  if ($notnull_bool(c >= 48 && c <= 57)) {
     return c - 48;
   }
-  else if (c >= 97 && c <= 102) {
+  else if ($notnull_bool(c >= 97 && c <= 102)) {
     return c - 87;
   }
-  else if (c >= 65 && c <= 70) {
+  else if ($notnull_bool(c >= 65 && c <= 70)) {
     return c - 55;
   }
   else {
     return -1;
   }
 }
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
-   i < hex.length; i++) {
+   $notnull_bool(i < hex.length); i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
-    result = (result << 4) + digit;
+    $assert($ne(digit, -1), "digit != -1", "parser.dart", 1238, 14);
+    result = (result << 4) + $assert_num(digit);
   }
   return result;
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type0 = this.type(0);
   var name = null;
-  if (this._maybeEat(14/*TokenKind.DOT*/)) {
+  if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   var args = this.arguments();
   return new lang_NewExpression(isConst, type0, name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.finishListLiteral = function(start, isConst, type0) {
-  if (this._maybeEat(56/*TokenKind.INDEX*/)) {
+  if ($notnull_bool(this._maybeEat(56/*TokenKind.INDEX*/))) {
     return new ListExpression(isConst, type0, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
-  while (!this._maybeEat(5/*TokenKind.RBRACK*/)) {
-    if (this.isPrematureEndOfFile()) break;
+  while ($notnull_bool(!this._maybeEat(5/*TokenKind.RBRACK*/))) {
+    if ($notnull_bool(this.isPrematureEndOfFile())) break;
     values.add(this.expression());
-    if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
+    if ($notnull_bool(!this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type0, values, this._makeSpan(start));
 }
 lang_Parser.prototype.finishMapLiteral = function(start, isConst, type0) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
-    if (this.isPrematureEndOfFile()) break;
+  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 (!this._maybeEat(11/*TokenKind.COMMA*/)) {
+    if ($notnull_bool(!this._maybeEat(11/*TokenKind.COMMA*/))) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type0, items, this._makeSpan(start));
 }
 lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
-  var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
-  var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
-  if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
-    return this.finishListLiteral(start, isConst, genericType);
+  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 (this._peekKind(6/*TokenKind.LBRACE*/)) {
-    return this.finishMapLiteral(start, isConst, genericType);
+  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 (true) {
+  while ($notnull_bool(true)) {
     switch (this._peek()) {
-      case 85/*TokenKind.STATIC*/:
-      case 96/*TokenKind.FINAL*/:
-      case 90/*TokenKind.CONST*/:
-      case 70/*TokenKind.ABSTRACT*/:
-      case 74/*TokenKind.FACTORY*/:
+      case 86/*TokenKind.STATIC*/:
+      case 97/*TokenKind.FINAL*/:
+      case 91/*TokenKind.CONST*/:
+      case 71/*TokenKind.ABSTRACT*/:
+      case 75/*TokenKind.FACTORY*/:
 
-        if (modifiers == null) modifiers = [];
+        if ($notnull_bool(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 (this._maybeEat(73/*TokenKind.EXTENDS*/)) {
+  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 ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
+    if ($notnull_bool((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0)) {
       closed = true;
       break;
     }
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
-  if (!closed) {
+  while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
+  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 (this._maybeEat(53/*TokenKind.GT*/)) {
+  if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     return depth;
   }
-  else if (depth > 0 && this._maybeEat(40/*TokenKind.SAR*/)) {
+  else if ($notnull_bool(depth > 0 && this._maybeEat(40/*TokenKind.SAR*/))) {
     return depth - 1;
   }
-  else if (depth > 1 && this._maybeEat(41/*TokenKind.SHR*/)) {
+  else if ($notnull_bool(depth > 1 && this._maybeEat(41/*TokenKind.SHR*/))) {
     return depth - 2;
   }
   else {
     this._errorExpected('>');
     return depth;
   }
 }
 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 ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
+    if ($notnull_bool((myType instanceof GenericTypeReference) && myType.depth <= depth)) {
       delta = depth - myType.depth;
       break;
     }
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
-  if (delta >= 0) {
-    depth = depth - delta;
+  while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
+  if ($notnull_bool(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);
+  return new GenericTypeReference(baseType, types, depth, (span && span.is$SourceSpan()));
 }
 lang_Parser.prototype.typeList = function() {
   var types = [];
   do {
     types.add(this.type(0));
   }
-  while (this._maybeEat(11/*TokenKind.COMMA*/))
+  while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   return types;
 }
 lang_Parser.prototype.type = function(depth) {
   var start = this._peekToken.start;
   var name;
   var names = null;
   var typeArgs = null;
   var isFinal = false;
   switch (this._peek()) {
-    case 112/*TokenKind.VOID*/:
+    case 113/*TokenKind.VOID*/:
 
       return new TypeReference(this._lang_next().get$span(), world.voidType);
 
-    case 111/*TokenKind.VAR*/:
+    case 112/*TokenKind.VAR*/:
 
       return new TypeReference(this._lang_next().get$span(), world.varType);
 
-    case 96/*TokenKind.FINAL*/:
+    case 97/*TokenKind.FINAL*/:
 
-      this._eat(96/*TokenKind.FINAL*/);
+      this._eat(97/*TokenKind.FINAL*/);
       isFinal = true;
       name = this.identifier();
       break;
 
     default:
 
       name = this.identifier();
       break;
 
   }
-  while (this._maybeEat(14/*TokenKind.DOT*/)) {
-    if (names == null) names = [];
+  while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
+    if ($notnull_bool(names == null)) names = [];
     names.add(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
-  if (this._peekKind(52/*TokenKind.LT*/)) {
-    return this.addTypeArguments(typeRef, depth);
+  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 type0 = di.type;
   var name = di.get$name();
   var value = null;
-  if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
-    if (!inOptionalBlock) {
+  if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
+    if ($notnull_bool(!inOptionalBlock)) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
-  else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
+  else if ($notnull_bool(this._peekKind(2/*TokenKind.LPAREN*/))) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type0, name, formals, null, null, this._makeSpan(start));
     type0 = new FunctionTypeReference(false, func, func.get$span());
   }
-  if (inOptionalBlock && value == null) {
+  if ($notnull_bool(inOptionalBlock && value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type0, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
-  if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
-    if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
+  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
+    if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
       inOptionalBlock = true;
     }
-    formals.add(this.formalParameter(inOptionalBlock));
-    while (this._maybeEat(11/*TokenKind.COMMA*/)) {
-      if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
-        if (inOptionalBlock) {
+    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(inOptionalBlock));
+      formals.add(this.formalParameter($assert_bool(inOptionalBlock)));
     }
-    if (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 (!TokenKind.isIdentifier(tok.kind)) {
+  if ($notnull_bool(!TokenKind.isIdentifier(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, type0;
-  if ((expr instanceof CallExpression)) {
-    if ((expr.target instanceof VarExpression)) {
+  if ($notnull_bool((expr instanceof CallExpression))) {
+    if ($notnull_bool((expr.target instanceof VarExpression))) {
       name = expr.target.get$name();
       type0 = null;
     }
-    else if ((expr.target instanceof DeclaredIdentifier)) {
+    else if ($notnull_bool((expr.target instanceof DeclaredIdentifier))) {
       name = expr.target.get$name();
       type0 = 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, type0, name, formals, null, body, span);
+    var func = new FunctionDefinition(null, type0, 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) {
-  if ((expr instanceof VarExpression)) {
+  if ($notnull_bool((expr instanceof VarExpression))) {
     return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
   }
-  else if ((expr instanceof DeclaredIdentifier)) {
+  else if ($notnull_bool((expr instanceof DeclaredIdentifier))) {
     return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
   }
-  else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier))) {
+  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
     var di = expr.x;
     return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
   }
-  else if (this._isBin(expr, 52/*TokenKind.LT*/)) {
+  else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/))) {
     return null;
   }
-  else if ((expr instanceof ListExpression)) {
+  else if ($notnull_bool((expr instanceof ListExpression))) {
     return this._makeFormalsFromList(expr);
   }
   else {
     this._lang_error('expected formal', expr.get$span());
   }
 }
 lang_Parser.prototype._makeFormalsFromList = function(expr) {
-  if (expr.get$isConst()) {
+  if ($notnull_bool(expr.get$isConst())) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
-  else if ($ne(expr.type, null)) {
+  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(arguments0) {
   var expressions = [];
   for (var i = 0;
-   i < arguments0.length; i++) {
+   $notnull_bool(i < arguments0.length); i++) {
     var arg = arguments0.$index(i);
-    if (arg.label != null) {
+    if ($notnull_bool(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 formals = [];
   for (var i = 0;
-   i < expressions.length; i++) {
+   $notnull_bool(i < expressions.length); i++) {
     var formal = this._makeFormal(expressions.$index(i));
-    if (formal == null) {
+    if ($notnull_bool(formal == null)) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
-      while (i < expressions.length) {
+      while ($notnull_bool(i < expressions.length)) {
         var expr = expressions.$index(i++);
-        if (this._isBin(expr, 53/*TokenKind.GT*/)) {
+        if ($notnull_bool(this._isBin(expr, 53/*TokenKind.GT*/))) {
           typeParams.add(this._makeType(expr.x));
           var type0 = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
           var name = null;
-          if ((expr.y instanceof VarExpression)) {
+          if ($notnull_bool((expr.y instanceof VarExpression))) {
             var ve = expr.y;
             name = ve.name;
           }
           else {
             this._lang_error('expected formal', expr.get$span());
           }
           formal = new FormalNode(false, false, type0, name, null, this._makeSpan(expressions.$index(0).get$span().start));
           break;
         }
         else {
           typeParams.add(this._makeType(expr));
         }
       }
       formals.add(formal);
     }
-    else if (!!(formal && formal.is$List)) {
+    else if ($notnull_bool(!!(formal && formal.is$List))) {
       formals.addAll(formal);
-      if (!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 ((e instanceof VarExpression)) {
+  if ($notnull_bool((e instanceof VarExpression))) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
-  else if ((e instanceof DeclaredIdentifier)) {
+  else if ($notnull_bool((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 ((expr instanceof VarExpression)) {
+  if ($notnull_bool((expr instanceof VarExpression))) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
 }
 // ********** 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; };
 // ********** Code for Definition **************
 function Definition(span0) {
   lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(Definition, lang_Statement);
+Definition.prototype.is$Definition = function(){return this;};
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
 // ********** Code for lang_Statement **************
 function lang_Statement(span0) {
   lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(lang_Statement, lang_Node);
+lang_Statement.prototype.is$lang_Statement = function(){return this;};
 // ********** Code for lang_Expression **************
 function lang_Expression(span0) {
   lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(lang_Expression, lang_Node);
+lang_Expression.prototype.is$lang_Expression = function(){return this;};
 // ********** Code for TypeReference **************
 function TypeReference(span0, type) {
   this.type = type;
   lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(TypeReference, lang_Node);
+TypeReference.prototype.is$TypeReference = function(){return this;};
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 // ********** Code for DirectiveDefinition **************
 function DirectiveDefinition(name, arguments, span0) {
   this.name = name;
   this.arguments = arguments;
   Definition.call(this, span0);
   // Initializers done
 }
@@ skipping 59 matching lines @@
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
   this.initializers = initializers;
   this.body = body;
   Definition.call(this, span0);
   // Initializers done
 }
 $inherits(FunctionDefinition, Definition);
+FunctionDefinition.prototype.is$FunctionDefinition = function(){return this;};
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 // ********** Code for ReturnStatement **************
 function ReturnStatement(value, span0) {
   this.value = value;
@@ skipping 202 matching lines @@
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span0) {
   this.target = target;
   this.arguments = arguments;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(CallExpression, lang_Expression);
+CallExpression.prototype.is$CallExpression = function(){return this;};
 CallExpression.prototype.get$arguments = function() { return this.arguments; };
 CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span0) {
   this.target = target;
   this.index = index;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(IndexExpression, lang_Expression);
+IndexExpression.prototype.is$IndexExpression = function(){return this;};
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 // ********** Code for BinaryExpression **************
 function BinaryExpression(op, x, y, span0) {
   this.op = op;
   this.x = x;
   this.y = y;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(BinaryExpression, lang_Expression);
+BinaryExpression.prototype.is$BinaryExpression = function(){return this;};
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span0) {
   this.op = op;
   this.self = self;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(UnaryExpression, lang_Expression);
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 // ********** Code for PostfixExpression **************
 function PostfixExpression(body, op, span0) {
   this.body = body;
   this.op = op;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(PostfixExpression, lang_Expression);
+PostfixExpression.prototype.is$PostfixExpression = function(){return this;};
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 // ********** Code for lang_NewExpression **************
 function lang_NewExpression(isConst, type, name, arguments, span0) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
   lang_Expression.call(this, span0);
@@ skipping 72 matching lines @@
   return visitor.visitParenExpression(this);
 }
 // ********** Code for DotExpression **************
 function DotExpression(self, name, span0) {
   this.self = self;
   this.name = name;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(DotExpression, lang_Expression);
+DotExpression.prototype.is$DotExpression = function(){return this;};
 DotExpression.prototype.get$name = function() { return this.name; };
 DotExpression.prototype.set$name = function(value) { return this.name = value; };
 DotExpression.prototype.visit = function(visitor) {
   return visitor.visitDotExpression(this);
 }
 // ********** Code for VarExpression **************
 function VarExpression(name, span0) {
   this.name = name;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(VarExpression, lang_Expression);
+VarExpression.prototype.is$VarExpression = function(){return this;};
 VarExpression.prototype.get$name = function() { return this.name; };
 VarExpression.prototype.set$name = function(value) { return this.name = value; };
 VarExpression.prototype.visit = function(visitor) {
   return visitor.visitVarExpression(this);
 }
 // ********** Code for ThisExpression **************
 function ThisExpression(span0) {
   lang_Expression.call(this, span0);
   // Initializers done
 }
@@ skipping 37 matching lines @@
 }
 // ********** Code for NameTypeReference **************
 function NameTypeReference(isFinal, name, names, span0) {
   this.isFinal = isFinal;
   this.name = name;
   this.names = names;
   TypeReference.call(this, span0);
   // Initializers done
 }
 $inherits(NameTypeReference, TypeReference);
+NameTypeReference.prototype.is$NameTypeReference = function(){return this;};
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 // ********** Code for GenericTypeReference **************
 function GenericTypeReference(baseType, typeArguments, depth, span0) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
@@ skipping 16 matching lines @@
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span0) {
   this.label = label;
   this.value = value;
   lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(ArgumentNode, lang_Node);
+ArgumentNode.prototype.is$ArgumentNode = function(){return this;};
 ArgumentNode.prototype.get$value = function() { return this.value; };
 ArgumentNode.prototype.set$value = function(value) { return this.value = value; };
 ArgumentNode.prototype.visit = function(visitor) {
   return visitor.visitArgumentNode(this);
 }
 // ********** Code for FormalNode **************
 function FormalNode(isThis, isRest, type, name, value, span0) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
@@ skipping 62 matching lines @@
   return visitor.visitIdentifier(this);
 }
 // ********** Code for DeclaredIdentifier **************
 function DeclaredIdentifier(type, name, span0) {
   this.type = type;
   this.name = name;
   lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(DeclaredIdentifier, lang_Expression);
+DeclaredIdentifier.prototype.is$DeclaredIdentifier = function(){return this;};
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 // ********** Code for lang_Type **************
 function lang_Type(name) {
   this.name = name;
   this.isTested = false;
   // 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() {
-  if (this._typeMember == null) {
-    this._typeMember = new TypeMember(this);
+  var $0;
+  if ($notnull_bool(this._typeMember == null)) {
+    this._typeMember = new TypeMember((($0 = this) && $0.is$DefinedType()));
   }
   return this._typeMember;
 }
 lang_Type.prototype.getMember = function(name0) {
   return null;
 }
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
 lang_Type.prototype.get$isTop = function() {
@@ skipping 41 matching lines @@
 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 this._jsname == null ? this.name : this._jsname;
+  return $notnull_bool(this._jsname == null) ? this.name : this._jsname;
 }
 lang_Type.prototype.set$jsname = function(name0) {
   return this._jsname = name0;
 }
 lang_Type.prototype.get$typeArgsInOrder = function() {
   return null;
 }
 lang_Type.prototype.get$genericType = function() {
   return this;
 }
 lang_Type.prototype.get$interfaces = function() {
   return null;
 }
 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, span0, typeErrors) {
-  if (!this.isSubtypeOf(other)) {
+  if ($notnull_bool(!this.isSubtypeOf(other))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name + '');
-    if (typeErrors) {
-      world.error(msg, span0);
+    if ($notnull_bool(typeErrors)) {
+      world.error($assert_String(msg), span0);
     }
     else {
-      world.warning(msg, span0);
+      world.warning($assert_String(msg), span0);
     }
   }
 }
 lang_Type.prototype.needsVarCall = function(args) {
-  if (this.get$isVarOrFunction()) {
+  if ($notnull_bool(this.get$isVarOrFunction())) {
     return true;
   }
   var call = this.getCallMethod();
-  if ($ne(call, null)) {
-    if (args.get$length() != call.get$parameters().length || !call.namesInOrder(args)) {
+  if ($notnull_bool($ne(call, null))) {
+    if ($notnull_bool(args.get$length() != call.get$parameters().length || !call.namesInOrder(args))) {
       return true;
     }
   }
   return false;
 }
 lang_Type.union = function(x, y) {
-  if ($eq(x, y)) return x;
-  if (x.get$isNum() && y.get$isNum()) return world.numType;
-  if (x.get$isString() && y.get$isString()) return world.stringType;
+  if ($notnull_bool($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 this.isSubtypeOf(other) || other.isSubtypeOf(this);
 }
 lang_Type.prototype._isDirectSupertypeOf = function(other) {
   var $this = this; // closure support
-  if (other.get$isClass()) {
+  if ($notnull_bool(other.get$isClass())) {
     return $eq(other.get$parent(), this) || this.get$isObject() && other.get$parent() == null;
   }
   else {
-    if (other.get$interfaces() == null || other.get$interfaces().isEmpty()) {
+    if ($notnull_bool(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 ((other instanceof ParameterType)) {
+  if ($notnull_bool((other instanceof ParameterType))) {
     return true;
   }
-  if ($eq(this, other)) return true;
-  if (this.get$isVar()) return true;
-  if (other.get$isVar()) return true;
-  if (other._isDirectSupertypeOf(this)) return true;
+  if ($notnull_bool($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 ($ne(call, null) && $ne(otherCall, null)) {
-    return lang_Type._isFunctionSubtypeOf(call, otherCall);
+  if ($notnull_bool($ne(call, null) && $ne(otherCall, null))) {
+    return lang_Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
   }
-  if ($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($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 (t.hasNext()) {
-      if (!t.next().isSubtypeOf(s.next())) return false;
+    while ($notnull_bool(t.hasNext())) {
+      if ($notnull_bool(!t.next().isSubtypeOf(s.next()))) return false;
     }
     return true;
   }
-  if (this.get$parent() != null && this.get$parent().isSubtypeOf(other)) {
+  if ($notnull_bool(this.get$parent() != null && this.get$parent().isSubtypeOf(other))) {
     return true;
   }
-  if (this.get$interfaces() != null && this.get$interfaces().some((function (i) {
+  if ($notnull_bool(this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf(other);
   })
-  )) {
+  ))) {
     return true;
   }
   return false;
 }
 lang_Type._isFunctionSubtypeOf = function(t, s) {
-  if (!s.returnType.get$isVoid() && !s.returnType.isAssignable(t.returnType)) {
+  var $0;
+  if ($notnull_bool(!s.returnType.get$isVoid() && !s.returnType.isAssignable(t.returnType))) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
-  if (tp.length < sp.length) return false;
+  if ($notnull_bool(tp.length < sp.length)) return false;
   for (var i = 0;
-   i < sp.length; i++) {
-    if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
-    if (tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name())) return false;
-    if (!tp.$index(i).type.isAssignable(sp.$index(i).type)) return false;
+   $notnull_bool(i < sp.length); i++) {
+    if ($notnull_bool($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(!tp.$index(i).type.isAssignable((($0 = sp.$index(i).type) && $0.is$lang_Type())))) return false;
   }
-  if (tp.length > sp.length && !tp.$index(sp.length).get$isOptional()) return false;
+  if ($notnull_bool(tp.length > sp.length && !tp.$index(sp.length).get$isOptional())) return false;
   return true;
 }
 // ********** Code for ParameterType **************
 function ParameterType(name0, typeParameter) {
   this.typeParameter = typeParameter;
   lang_Type.call(this, name0);
   // Initializers done
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.get$isClass = function() {
@@ skipping 17 matching lines @@
 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.resolveTypeParams = function(inType) {
   return inType.typeArguments.$index(this.name);
 }
 ParameterType.prototype.resolve = function(inType) {
-  if (this.typeParameter.extendsType != null) {
+  if ($notnull_bool(this.typeParameter.extendsType != null)) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
   }
 }
 // ********** Code for ConcreteType **************
 function ConcreteType(name0, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
@@ skipping 26 matching lines @@
   })
   );
 }
 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 ($ne(newType, t)) needsNewType = true;
+    if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add(newType);
   }
-  if (!needsNewType) return this;
+  if ($notnull_bool(!needsNewType)) return this;
   return this.genericType.getOrMakeConcreteType(newTypeArgs);
 }
 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 (this._interfaces == null && this.genericType.get$interfaces() != null) {
+  if ($notnull_bool(this._interfaces == null && this.genericType.get$interfaces() != null)) {
     this._interfaces = [];
     var $list = this.genericType.get$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() {
   return this.genericType.getCallMethod();
 }
 ConcreteType.prototype.getAllMembers = function() {
+  var $0;
   var result = this.genericType.getAllMembers();
   var $list = result.getKeys();
   for (var $i = result.getKeys().iterator(); $i.hasNext(); ) {
     var memberName = $i.next();
     var myMember = this.members.$index(memberName);
-    if ($ne(myMember, null)) {
+    if ($notnull_bool($ne(myMember, null))) {
       result.$setindex(memberName, myMember);
     }
   }
   return result;
 }
 ConcreteType.prototype.markUsed = function() {
   this.genericType.markUsed();
 }
 ConcreteType.prototype.genMethod = function(method) {
   this.genericType.genMethod(method);
 }
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
-  if (genericMember == null) return null;
-  if ($ne(genericMember.declaringType, this.genericType)) {
-    if (!genericMember.declaringType.get$isGeneric()) return genericMember;
+  if ($notnull_bool(genericMember == null)) return null;
+  if ($notnull_bool($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 (genericMember.get$isFactory()) {
-    ret = new ConcreteMember(genericMember.get$name(), this, genericMember);
-    this.factories.addFactory(this.name, constructorName, ret);
+  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);
   }
   return ret;
 }
 ConcreteType.prototype.getMember = function(memberName) {
   var ret = this.members.$index(memberName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   var genericMember = this.genericType.getMember(memberName);
-  if (genericMember == null) return null;
-  ret = new ConcreteMember(genericMember.get$name(), this, genericMember);
+  if ($notnull_bool(genericMember == null)) return null;
+  ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
   this.members.$setindex(memberName, ret);
   return ret;
 }
 ConcreteType.prototype.resolveMember = function(memberName) {
+  var $0;
   var mem = this.getMember(memberName);
-  if (mem == null) return null;
-  var ret = new MemberSet(mem);
-  if (mem.get$isStatic()) return ret;
+  if ($notnull_bool(mem == null)) return null;
+  var ret = new MemberSet((mem && mem.is$Member()));
+  if ($notnull_bool(mem.get$isStatic())) return ret;
   var $list = this.genericType.get$subtypes();
   for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext(); ) {
     var t = $i.next();
     var m = t.members.$index(memberName);
-    if ($ne(m, null)) ret.add(m);
+    if ($notnull_bool($ne(m, null))) ret.add(m);
   }
   return ret;
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
   return ret;
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 // ********** Code for DefinedType **************
 function DefinedType(name0, library, definition0, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = new HashSetImplementation$Type();
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
   lang_Type.call(this, name0);
   // Initializers done
   this.setDefinition(definition0);
 }
 $inherits(DefinedType, lang_Type);
+DefinedType.prototype.is$DefinedType = function(){return this;};
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
 DefinedType.prototype.get$parent = function() { return this.parent; };
 DefinedType.prototype.set$parent = function(value) { return this.parent = value; };
 DefinedType.prototype.get$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 DefinedType.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefinedType.prototype.set$typeParameters = function(value) { return this.typeParameters = 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", 541, 12);
   this.definition = def;
-  if ((this.definition instanceof TypeDefinition) && this.definition.nativeType != null) {
+  if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.nativeType != null)) {
     this.isNativeType = true;
   }
-  if (this.definition != null && this.definition.get$typeParameters() != null) {
+  if ($notnull_bool(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(paramName, tp));
+      this.typeParameters.add(new ParameterType($assert_String(paramName), tp));
     }
   }
 }
 DefinedType.prototype.get$typeArgsInOrder = function() {
-  if (this.typeParameters == null) return null;
-  if (this._typeArgsInOrder == null) {
+  if ($notnull_bool(this.typeParameters == null)) return null;
+  if ($notnull_bool(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 12 matching lines @@
 DefinedType.prototype.get$isFunction = function() {
   return this.library.get$isCore() && this.name == 'Function';
 }
 DefinedType.prototype.get$isList = function() {
   return this.library.get$isCore() && this.name == 'List';
 }
 DefinedType.prototype.get$isGeneric = function() {
   return this.typeParameters != null;
 }
 DefinedType.prototype.get$span = function() {
-  return this.definition == null ? null : this.definition.span;
+  return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 DefinedType.prototype.get$typeofName = function() {
-  if (!this.library.get$isCore()) return null;
-  if (this.get$isBool()) return 'boolean';
-  else if (this.get$isNum()) return 'number';
-  else if (this.get$isString()) return 'string';
-  else if (this.get$isFunction()) return 'function';
+  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 this.library != null && this.library.get$isCore() && (this.name == 'num' || this.name == 'int' || this.name == 'double');
 }
 DefinedType.prototype.getCallMethod = function() {
   return this.members.$index('\$call');
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
-  if (this.isUsed) return;
+  if ($notnull_bool(this.isUsed)) return;
   this.isUsed = true;
-  if (this._lazyGenMethods != null) {
+  if ($notnull_bool(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);
+      world.gen.genMethod((method && method.is$Member()));
     }
     this._lazyGenMethods = null;
   }
-  if (this.parent != null) this.parent.markUsed();
+  if ($notnull_bool(this.parent != null)) this.parent.markUsed();
 }
 DefinedType.prototype.genMethod = function(method) {
-  if (this.isUsed) {
+  if ($notnull_bool(this.isUsed)) {
     world.gen.genMethod(method);
   }
-  else if (this.isClass) {
-    if (this._lazyGenMethods == null) this._lazyGenMethods = $map([]);
+  else if ($notnull_bool(this.isClass)) {
+    if ($notnull_bool(this._lazyGenMethods == null)) this._lazyGenMethods = $map([]);
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
-  if (types == null) return [];
+  if ($notnull_bool(types == null)) return [];
   var interfaces0 = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
-    var resolvedInterface = this.resolveType(type, true);
-    if (resolvedInterface.get$isClosed() && !(this.library.get$isCore() || this.library.get$isCoreImpl())) {
+    var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
+    if ($notnull_bool(resolvedInterface.get$isClosed() && !(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);
     interfaces0.add(resolvedInterface);
   }
   return interfaces0;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 657, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
-  if (this._subtypes == null) {
+  var $0;
+  if ($notnull_bool(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.parent;
-  while ($ne(ancestor, null)) {
-    if (ancestor === this) {
+  while ($notnull_bool($ne(ancestor, null))) {
+    if ($notnull_bool(ancestor === this)) {
       return true;
     }
-    if (seen.contains(ancestor)) {
+    if ($notnull_bool(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 (ancestor == null) return false;
-    if (ancestor === $this) return true;
-    if (seen.contains(ancestor)) {
+    if ($notnull_bool(ancestor == null)) return false;
+    if ($notnull_bool(ancestor === $this)) return true;
+    if ($notnull_bool(seen.contains(ancestor))) {
       return false;
     }
     seen.add(ancestor);
-    if (ancestor.get$interfaces() != null) {
+    if ($notnull_bool(ancestor.get$interfaces() != null)) {
       var $list = ancestor.get$interfaces();
       for (var $i = 0;$i < $list.length; $i++) {
         var parent0 = $list.$index($i);
-        if (_helper(parent0)) return true;
+        if ($notnull_bool(_helper(parent0))) return true;
       }
     }
     return false;
   }
   for (var i = 0;
-   i < this.interfaces.length; i++) {
-    if (_helper(this.interfaces.$index(i))) return i;
+   $notnull_bool(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
-  if ((this.definition instanceof TypeDefinition)) {
-    if (this.isClass) {
-      if (this.definition.extendsTypes != null && this.definition.extendsTypes.length > 0) {
-        if (this.definition.extendsTypes.length > 1) {
+  var $0;
+  if ($notnull_bool((this.definition instanceof TypeDefinition))) {
+    if ($notnull_bool(this.isClass)) {
+      if ($notnull_bool(this.definition.extendsTypes != null && this.definition.extendsTypes.length > 0)) {
+        if ($notnull_bool(this.definition.extendsTypes.length > 1)) {
           world.error('more than one base class', this.definition.extendsTypes.$index(1).get$span());
         }
         var extendsTypeRef = this.definition.extendsTypes.$index(0);
-        if ((extendsTypeRef instanceof GenericTypeReference)) {
+        if ($notnull_bool((extendsTypeRef instanceof GenericTypeReference))) {
           var g = extendsTypeRef;
           this.parent = this.resolveType(g.baseType, true);
         }
-        this.parent = this.resolveType(extendsTypeRef, true);
-        if (!this.parent.get$isClass()) {
+        this.parent = this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true);
+        if ($notnull_bool(!this.parent.get$isClass())) {
           world.error('class may not extend an interface - use implements', this.definition.extendsTypes.$index(0).get$span());
         }
         this.parent.addDirectSubtype(this);
-        if (this._cycleInClassExtends()) {
+        if ($notnull_bool(this._cycleInClassExtends())) {
           world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
         }
       }
       else {
-        if (!this.get$isObject()) {
+        if ($notnull_bool(!this.get$isObject())) {
           this.parent = world.objectType;
         }
       }
       this.interfaces = this._resolveInterfaces(this.definition.implementsTypes);
-      if (this.definition.factoryType != null) {
+      if ($notnull_bool(this.definition.factoryType != null)) {
         world.error('factory not allowed on classes', this.definition.factoryType.span);
       }
     }
     else {
-      if (this.definition.implementsTypes != null && this.definition.implementsTypes.length > 0) {
+      if ($notnull_bool(this.definition.implementsTypes != null && this.definition.implementsTypes.length > 0)) {
         world.error('implements not allowed on interfaces (use extends)', this.definition.implementsTypes.$index(0).get$span());
       }
       this.interfaces = this._resolveInterfaces(this.definition.extendsTypes);
       var res = this._cycleInInterfaceExtends();
-      if (res >= 0) {
+      if ($notnull_bool(res >= 0)) {
         world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), this.definition.extendsTypes.$index(res).get$span());
       }
-      if (this.definition.factoryType != null) {
+      if ($notnull_bool(this.definition.factoryType != null)) {
         this.factory_ = this.resolveType(this.definition.factoryType, true);
-        if (this.factory_ == null) {
+        if ($notnull_bool(this.factory_ == null)) {
           world.info(('unresolved factory: ' + this.definition.factoryType.get$name().get$name() + ''), this.definition.factoryType.get$name().get$span());
         }
       }
     }
   }
-  else if ((this.definition instanceof FunctionTypeDefinition)) {
+  else if ($notnull_bool((this.definition instanceof FunctionTypeDefinition))) {
     this.interfaces = [world.functionType];
   }
-  if (this.typeParameters != null) {
+  if ($notnull_bool(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, definition0) {
-  if (methodName == null) methodName = definition0.name.name;
+  if ($notnull_bool(methodName == null)) methodName = definition0.name.name;
   var method = new MethodMember(methodName, this, definition0);
-  if (method.get$isConstructor()) {
-    if (this.constructors.containsKey(method.get$constructorName())) {
+  if ($notnull_bool(method.get$isConstructor())) {
+    if ($notnull_bool(this.constructors.containsKey(method.get$constructorName()))) {
       world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition0.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition0.modifiers != null && definition0.modifiers.length == 1 && definition0.modifiers.$index(0).kind == 74/*TokenKind.FACTORY*/) {
-    if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
+  if ($notnull_bool(definition0.modifiers != null && definition0.modifiers.length == 1 && definition0.modifiers.$index(0).kind == 75/*TokenKind.FACTORY*/)) {
+    if ($notnull_bool(this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null)) {
       world.error(('duplicate factory definition of ' + method.get$name() + ''), definition0.span);
       return;
     }
-    this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
+    this.factories.addFactory(method.get$constructorName(), $assert_String(method.get$name()), (method && method.is$Member()));
     return;
   }
-  if (methodName.startsWith('get\$') || methodName.startsWith('set\$')) {
+  if ($notnull_bool(methodName.startsWith('get\$') || methodName.startsWith('set\$'))) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
-    if (prop == null) {
-      prop = new PropertyMember(propName, this);
+    if ($notnull_bool(prop == null)) {
+      prop = new PropertyMember($assert_String(propName), this);
       this.members.$setindex(propName, prop);
     }
-    if (!(prop instanceof PropertyMember)) {
+    if ($notnull_bool(!(prop instanceof PropertyMember))) {
       world.error(('property conflicts with field name: ' + propName + ''), definition0.span);
       return;
     }
-    if (methodName[0] == 'g') {
-      if (prop.getter != null) {
+    if ($notnull_bool(methodName[0] == 'g')) {
+      if ($notnull_bool(prop.getter != null)) {
         world.error(('duplicate getter definition for ' + propName + ''), definition0.span);
       }
-      prop.getter = method;
+      prop.getter = (method && method.is$MethodMember());
     }
     else {
-      if (prop.setter != null) {
+      if ($notnull_bool(prop.setter != null)) {
         world.error(('duplicate setter definition for ' + propName + ''), definition0.span);
       }
-      prop.setter = method;
+      prop.setter = (method && method.is$MethodMember());
     }
     return;
   }
-  if (this.members.containsKey(methodName)) {
+  if ($notnull_bool(this.members.containsKey(methodName))) {
     world.error(('duplicate method definition of ' + method.get$name() + ''), definition0.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition0) {
   for (var i = 0;
-   i < definition0.names.length; i++) {
+   $notnull_bool(i < definition0.names.length); i++) {
     var name0 = definition0.names.$index(i).get$name();
-    if (this.members.containsKey(name0)) {
+    if ($notnull_bool(this.members.containsKey(name0))) {
       world.error(('duplicate field definition of ' + name0 + ''), definition0.span);
       return;
     }
     var value = null;
-    if (definition0.values != null) {
+    if ($notnull_bool(definition0.values != null)) {
       value = definition0.values.$index(i);
     }
-    var field = new FieldMember(name0, this, definition0, value);
+    var field = new FieldMember($assert_String(name0), this, definition0, value);
     this.members.$setindex(name0, field);
-    if (this.isNativeType) {
+    if ($notnull_bool(this.isNativeType)) {
       field.isNative = true;
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.constructors.$index(constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
-  if ($ne(ret, null)) {
-    if (this.factory_ != null) {
+  if ($notnull_bool($ne(ret, null))) {
+    if ($notnull_bool(this.factory_ != null)) {
       return this.factory_.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
-  if ($ne(ret, null)) return ret;
+  if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._tryCreateDefaultConstructor = function(name0) {
-  if (name0 == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0) {
+  if ($notnull_bool(name0 == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0)) {
     var span0 = this.definition.span;
     var inits = null, body = null;
-    if (this.isNativeType) {
-      body = new NativeStatement(null, span0);
+    if ($notnull_bool(this.isNativeType)) {
+      body = new NativeStatement(null, (span0 && span0.is$SourceSpan()));
       inits = null;
     }
     else {
       body = null;
-      inits = [new CallExpression(new SuperExpression(span0), [], span0)];
+      inits = [new CallExpression(new SuperExpression((span0 && span0.is$SourceSpan())), [], (span0 && span0.is$SourceSpan()))];
     }
-    var c = new FunctionDefinition(null, null, this.definition.get$name(), [], inits, body, span0);
-    this.addMethod(null, c);
+    var c = new FunctionDefinition(null, null, this.definition.get$name(), [], inits, body, (span0 && span0.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 member = this.members.$index(memberName);
-  if (member != null) {
+  if ($notnull_bool(member != null)) {
     var parentMember = this.getMemberInParents(memberName);
-    if ($ne(parentMember, null)) {
-      if (!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library())) {
+    if ($notnull_bool($ne(parentMember, null))) {
+      if ($notnull_bool(!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library()))) {
         member.override(parentMember);
       }
     }
     return member;
   }
-  if (this.get$isTop()) {
+  if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
-    if ($ne(libType, null)) {
+    if ($notnull_bool($ne(libType, null))) {
       return libType.get$typeMember();
     }
   }
   return this.getMemberInParents(memberName);
 }
 DefinedType.prototype.getMemberInParents = function(memberName) {
-  if (this.isClass) {
-    if (this.parent != null) {
+  if ($notnull_bool(this.isClass)) {
+    if ($notnull_bool(this.parent != null)) {
       return this.parent.getMember(memberName);
     }
-    else if (this.get$isObject()) {
-      if (memberName == '\$ne') {
+    else if ($notnull_bool(this.get$isObject())) {
+      if ($notnull_bool(memberName == '\$ne')) {
         var ret = this._createNotEqualMember();
         this.members.$setindex(memberName, ret);
         return ret;
       }
       return null;
     }
   }
   else {
-    if (this.interfaces != null && this.interfaces.length > 0) {
+    if ($notnull_bool(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 ($ne(ret, null)) {
+        if ($notnull_bool($ne(ret, null))) {
           return ret;
         }
       }
       return null;
     }
     else {
       return world.objectType.getMember(memberName);
     }
   }
 }
 DefinedType.prototype.resolveMember = function(memberName) {
+  var $0;
   var ret = this._resolvedMembers.$index(memberName);
-  if (ret != null) return ret;
+  if ($notnull_bool(ret != null)) return ret;
   var member = this.getMember(memberName);
-  if (member == null) {
+  if ($notnull_bool(member == null)) {
     return null;
   }
   ret = new MemberSet(member);
   this._resolvedMembers.$setindex(memberName, ret);
-  if (member.get$isStatic()) {
+  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 (!this.isClass && t.get$isClass()) {
+      if ($notnull_bool(!this.isClass && t.get$isClass())) {
         m = t.getMember(memberName);
       }
       else {
         m = t.members.$index(memberName);
       }
-      if ($ne(m, null)) ret.add(m);
+      if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
     }
     return ret;
   }
 }
 DefinedType.prototype._createNotEqualMember = function() {
   var eq = this.members.$index('\$eq');
-  if (eq == null) {
+  if ($notnull_bool(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 (type.names != null) {
+  if ($notnull_bool(type.names != null)) {
     var names = map(type.names, (function (n) {
       return n.get$name();
     })
     );
-    return type.name.name + '.' + Strings.join(names, '.');
+    return type.name.name + '.' + Strings.join((names && names.is$List$String()), '.');
   }
   else {
     return type.name.name;
   }
 }
 DefinedType.prototype.resolveType = function(node, typeErrors) {
-  if (node == null) return world.varType;
-  if (node.type != null) return node.type;
-  if ((node instanceof NameTypeReference)) {
+  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))) {
     var name0;
-    if (node.names != null) {
-      name0 = node.names.last().get$name();
+    if ($notnull_bool(node.names != null)) {
+      name0 = $assert_String(node.names.last().get$name());
     }
     else {
-      name0 = node.get$name().get$name();
+      name0 = $assert_String(node.get$name().get$name());
     }
-    if (this.typeParameters != null) {
+    if ($notnull_bool(this.typeParameters != null)) {
       var $list = this.typeParameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var tp = $list.$index($i);
-        if ($eq(tp.get$name(), name0)) {
-          node.type = tp;
+        if ($notnull_bool($eq(tp.get$name(), name0))) {
+          node.type = (tp && tp.is$lang_Type());
         }
       }
     }
-    if (node.type == null) {
-      node.type = this.library.findType(node);
+    if ($notnull_bool(node.type == null)) {
+      node.type = this.library.findType((node && node.is$NameTypeReference()));
     }
-    if (node.type == null) {
-      var message = ('can not find type ' + DefinedType._getDottedName(node) + '');
-      if (typeErrors) {
-        world.error(message, node.span);
+    if ($notnull_bool(node.type == null)) {
+      var message = ('can not find type ' + DefinedType._getDottedName((node && node.is$NameTypeReference())) + '');
+      if ($notnull_bool(typeErrors)) {
+        world.error($assert_String(message), node.span);
         node.type = world.objectType;
       }
       else {
-        world.warning(message, node.span);
+        world.warning($assert_String(message), node.span);
         node.type = world.varType;
       }
     }
   }
-  else if ((node instanceof GenericTypeReference)) {
+  else if ($notnull_bool((node instanceof GenericTypeReference))) {
     var baseType = this.resolveType(node.baseType, typeErrors);
-    if (!baseType.get$isGeneric()) {
+    if ($notnull_bool(!baseType.get$isGeneric())) {
       world.error(('' + baseType.get$name() + ' is not generic'), node.span);
       return null;
     }
-    if (node.typeArguments.length != baseType.get$typeParameters().length) {
+    if ($notnull_bool(node.typeArguments.length != baseType.get$typeParameters().length)) {
       world.error('wrong number of type arguments', node.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
-     i < node.typeArguments.length; i++) {
+     $notnull_bool(i < node.typeArguments.length); i++) {
       var extendsType = baseType.get$typeParameters().$index(i).extendsType;
-      var typeArg = this.resolveType(node.typeArguments.$index(i), typeErrors);
+      var typeArg = this.resolveType((($0 = node.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
       typeArgs.add(typeArg);
-      if ($ne(extendsType, null) && !(typeArg instanceof ParameterType)) {
-        typeArg.ensureSubtypeOf(extendsType, node.typeArguments.$index(i).get$span(), typeErrors);
+      if ($notnull_bool($ne(extendsType, null) && !(typeArg instanceof ParameterType))) {
+        typeArg.ensureSubtypeOf((extendsType && extendsType.is$lang_Type()), node.typeArguments.$index(i).get$span(), typeErrors);
       }
     }
     node.type = baseType.getOrMakeConcreteType(typeArgs);
   }
-  else if ((node instanceof FunctionTypeReference)) {
+  else if ($notnull_bool((node instanceof FunctionTypeReference))) {
     var name0 = '';
-    if (node.func.name != null) name0 = node.func.name.name;
-    node.type = this.library.getOrAddFunctionType(name0, node.func, this);
+    if ($notnull_bool(node.func.name != null)) name0 = node.func.name.name;
+    node.type = this.library.getOrAddFunctionType($assert_String(name0), node.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", 1136, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
-   i < typeArgs.length; i++) {
+   $notnull_bool(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, '\$');
+  var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
-  if (ret == null) {
-    ret = new ConcreteType(concreteName, this, typeMap, typeArgs);
+  if ($notnull_bool(ret == null)) {
+    ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return ret;
 }
 DefinedType.prototype.getCallStub = function(args) {
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1156, 12);
   var name0 = _getCallStubName('call', args);
-  if (this.varStubs == null) this.varStubs = $map([]);
+  if ($notnull_bool(this.varStubs == null)) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name0);
-  if (stub == null) {
-    stub = new VarFunctionStub(name0, args);
+  if ($notnull_bool(stub == null)) {
+    stub = new VarFunctionStub($assert_String(name0), args);
     this.varStubs.$setindex(name0, stub);
   }
   return stub;
 }
 // ********** Code for FixedCollection **************
 function FixedCollection(value, length) {
   this.value = value;
   this.length = length;
   // Initializers done
 }
+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;
 }
 FixedCollection.prototype.forEach$1 = FixedCollection.prototype.forEach;
 // ********** 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$Iterable = function(){return this;};
 // ********** Code for FixedIterator **************
 function FixedIterator(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
 FixedIterator.prototype.get$value = function() { return this.value; };
 FixedIterator.prototype.hasNext = function() {
   return this._index < this.length;
@@ skipping 11 matching lines @@
 }
 $inherits(FixedIterator$E, FixedIterator);
 // ********** Code for Value **************
 function Value(type, code, isSuper, needsTemp, isType) {
   this.type = type;
   this.code = code;
   this.isSuper = isSuper;
   this.needsTemp = needsTemp;
   this.isType = isType;
   // Initializers done
-  if (this.type == null) this.type = world.varType;
+  if ($notnull_bool(this.type == null)) this.type = world.varType;
 }
+Value.prototype.is$Value = function(){return this;};
 Value.prototype.get$isConst = function() {
   return false;
 }
 Value.prototype.get_ = function(context, name, node) {
   var member = this._resolveMember(context, name, node);
-  if ($ne(member, null)) {
+  if ($notnull_bool($ne(member, null))) {
     member = member.get_$3(context, node, this);
   }
-  if ($ne(member, null)) {
+  if ($notnull_bool($ne(member, null))) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name + ''), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
   var member = this._resolveMember(context, name, node);
-  if ($ne(member, null)) {
+  if ($notnull_bool($ne(member, null))) {
     member = member.set_(context, node, this, value, isDynamic);
   }
-  if ($ne(member, null)) {
+  if ($notnull_bool($ne(member, null))) {
     return member;
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
-  if (this.type.get$isVar() && name == '\$ne') {
-    if (args.values.length != 1) {
+  if ($notnull_bool(this.type.get$isVar() && name == '\$ne')) {
+    if ($notnull_bool(args.values.length != 1)) {
       world.warning('wrong number of arguments for !=', node.span);
     }
     return new Value(null, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), false, true, false);
   }
-  if (name == '\$call') {
-    if (this.isType) {
+  if ($notnull_bool(name == '\$call')) {
+    if ($notnull_bool(this.isType)) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
-    if (this.type.needsVarCall(args)) {
+    if ($notnull_bool(this.type.needsVarCall(args))) {
       return this._varCall(context, args);
     }
   }
   var member = this._resolveMember(context, name, node);
-  if (member == null) {
+  if ($notnull_bool(member == null)) {
     return this.invokeNoSuchMethod(context, name, node, args);
   }
   else {
     return member.invoke(context, node, this, args, isDynamic);
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
-  if (this.type.get$isVar() && name == '\$ne') {
+  if ($notnull_bool(this.type.get$isVar() && name == '\$ne')) {
     return true;
   }
-  if (this.type.get$isVarOrFunction() && name == '\$call') {
+  if ($notnull_bool(this.type.get$isVarOrFunction() && name == '\$call')) {
     return true;
   }
   var member = this._tryResolveMember(context, name);
   return $ne(member, null) && member.canInvoke(context, args);
 }
 Value.prototype._tryResolveMember = function(context, name) {
   var member = null;
-  if (!this.type.get$isVar()) {
-    if (this.isSuper) {
+  if ($notnull_bool(!this.type.get$isVar())) {
+    if ($notnull_bool(this.isSuper)) {
       return this.type.getMember(name);
     }
     else {
       member = this.type.resolveMember(name);
     }
   }
-  if (member == null) {
+  if ($notnull_bool(member == null)) {
     member = context.findMembers(name);
   }
   return member;
 }
 Value.prototype._resolveMember = function(context, name, node) {
   var member = this._tryResolveMember(context, name);
-  if (member == null) {
-    if (this._tryResolveMember(context, 'noSuchMethod').members.length > 1) {
+  if ($notnull_bool(member == null)) {
+    if ($notnull_bool(this._tryResolveMember(context, 'noSuchMethod').members.length > 1)) {
       return null;
     }
-    var typeName = this.type.name == null ? this.type.get$library().name : this.type.name;
+    var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
     var message = ('can not resolve "' + name + '" on "' + typeName + '"');
-    if (this.isType) {
-      world.error(message, node.span);
+    if ($notnull_bool(this.isType)) {
+      world.error($assert_String(message), node.span);
     }
     else {
-      world.warning(message, node.span);
+      world.warning($assert_String(message), node.span);
     }
-    if (context.findMembers(name) == null) {
+    if ($notnull_bool(context.findMembers(name) == null)) {
       world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
     }
   }
   return member;
 }
 Value.prototype.checkFirstClass = function(span) {
-  if (this.isType) {
+  if ($notnull_bool(this.isType)) {
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
   return new Value(null, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), false, true, false);
 }
+Value.prototype.needsConversion = function(toType) {
+  var callMethod = toType.getCallMethod();
+  if ($notnull_bool($ne(callMethod, null))) {
+    var arity = callMethod.get$parameters().length;
+    var myCall = this.type.getCallMethod();
+    if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
+      return true;
+    }
+  }
+  if ($notnull_bool(options.enableTypeChecks)) {
+    var fromType = this.type;
+    if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
+      fromType = world.objectType;
+    }
+    var bothNum = this.type.get$isNum() && toType.get$isNum();
+    return fromType.isSubtypeOf(toType) || bothNum;
+  }
+  return false;
+}
 Value.prototype.convertTo = function(context, toType, node, isDynamic) {
-  var checked = options.enableTypeChecks && !isDynamic;
+  var checked = !isDynamic;
   var callMethod = toType.getCallMethod();
-  if ($ne(callMethod, null)) {
-    if (checked && !toType.isAssignable(this.type)) {
+  if ($notnull_bool($ne(callMethod, null))) {
+    if ($notnull_bool(checked && !toType.isAssignable(this.type))) {
       this.convertWarning(toType, node);
     }
     var arity = callMethod.get$parameters().length;
     var myCall = this.type.getCallMethod();
-    if (myCall == null || myCall.get$parameters().length != arity) {
+    if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
       var stub = world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       return new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), false, true, false);
     }
   }
-  if (!options.enableTypeChecks) {
+  if ($notnull_bool(!options.enableTypeChecks)) {
     return this;
   }
-  if (this.type.isSubtypeOf(toType)) {
+  var fromType = this.type;
+  if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
+    fromType = world.objectType;
+  }
+  var bothNum = this.type.get$isNum() && toType.get$isNum();
+  if ($notnull_bool(!checked || fromType.isSubtypeOf(toType) || bothNum)) {
     return this;
   }
-  else if (checked && !toType.isSubtypeOf(this.type)) {
+  if ($notnull_bool(!toType.isSubtypeOf(this.type))) {
     this.convertWarning(toType, node);
   }
   return this._typeAssert(context, toType, node);
 }
+Value.prototype.convertToNonNullBool = function(context, node) {
+  if ($notnull_bool(!this.type.isAssignable(world.boolType))) {
+    this.convertWarning(world.boolType, node);
+  }
+  if ($notnull_bool(!options.enableTypeChecks)) {
+    return this;
+  }
+  else {
+    if ($notnull_bool(this.code.startsWith('\$notnull_bool'))) {
+      return this;
+    }
+    else {
+      return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), false, true, false);
+    }
+  }
+}
 Value.prototype._typeAssert = function(context, toType, node) {
-  if ((toType instanceof ParameterType)) {
+  if ($notnull_bool((toType instanceof ParameterType))) {
     var p = toType;
     toType = p.extendsType;
   }
-  var temp = context.getTemp(this);
-  var testCode;
-  if (toType.get$library().get$isCore() && toType.get$typeofName() != null) {
-    testCode = ("typeof(" + temp.code + ") == '" + toType.get$typeofName() + "'");
+  if ($notnull_bool(toType.get$isObject() || toType.get$isVar())) {
+    world.internalError(('We thought ' + this.type.name + ' is not a subtype of ' + toType.name + '?'));
   }
-  else if (toType.get$isClass() && !(toType instanceof ConcreteType)) {
-    toType.markUsed();
-    testCode = ('' + temp.code + ' instanceof ' + toType.get$jsname() + '');
+  if ($notnull_bool(toType.get$isNum())) toType = world.numType;
+  var check;
+  if ($notnull_bool(toType.get$library().get$isCore() && toType.get$typeofName() != null)) {
+    check = ('\$assert_' + toType.name + '(' + this.code + ')');
+    if ($notnull_bool(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;
-    testCode = ('' + temp.code + '.is\$' + toType.get$jsname() + '');
+    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()));
   }
-  testCode = ('(' + context.assignTemp(temp, this).code + ' == null || ' + testCode + ')');
-  var test = new Value(world.boolType, testCode, false, true, false);
-  var err = world.corelib.types.$index('TypeError');
-  world.gen.genMethod(err.members.$index('toString'));
-  var args = new Arguments(null, [temp, new Value(world.stringType, ('"' + toType.name + '"'), false, true, false)]);
-  var typeErr = err.getConstructor('').invoke$4(context, node, null, args);
-  var result = new Value(toType, ('(' + test.code + ' ? ' + temp.code + ' : ') + ('\$throw(' + typeErr.code + '))'), false, true, false);
-  if ($ne(temp, this)) context.freeTemp(temp);
-  return result;
+  return new Value(toType, check, false, true, false);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
-  if (toType.get$isVar()) {
+  if ($notnull_bool(toType.get$isVar())) {
     world.error('can not resolve type', span);
     return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
   }
-  if ((toType instanceof ParameterType)) {
+  if ($notnull_bool((toType instanceof ParameterType))) {
     return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
   }
   var testCode = null;
-  if (toType.get$library().get$isCore()) {
+  if ($notnull_bool(toType.get$library().get$isCore())) {
     var typeofName = toType.get$typeofName();
-    if ($ne(typeofName, null)) {
-      testCode = ("(typeof(" + this.code + ") " + (isTrue ? '==' : '!=') + " '" + typeofName + "')");
+    if ($notnull_bool($ne(typeofName, null))) {
+      testCode = ("(typeof(" + this.code + ") " + ($notnull_bool(isTrue) ? '==' : '!=') + " '" + typeofName + "')");
     }
   }
-  if (toType.get$isClass() && !(toType instanceof ConcreteType)) {
+  if ($notnull_bool(toType.get$isClass() && !(toType instanceof ConcreteType))) {
     toType.markUsed();
     testCode = ('(' + this.code + ' instanceof ' + toType.get$jsname() + ')');
-    if (!isTrue) {
+    if ($notnull_bool(!isTrue)) {
       testCode = '!' + testCode;
     }
   }
-  if (testCode == null) {
+  if ($notnull_bool(testCode == null)) {
     toType.isTested = true;
     var temp = context.getTemp(this);
-    testCode = ('(' + context.assignTemp(temp, this).code + ' &&');
+    testCode = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     testCode = testCode + (' ' + temp.code + '.is\$' + toType.get$jsname() + ')');
-    if (isTrue) {
+    if ($notnull_bool(isTrue)) {
       testCode = '!!' + testCode;
     }
     else {
       testCode = '!' + testCode;
     }
-    if ($ne(this, temp)) context.freeTemp(temp);
+    if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
   }
   return new Value(world.boolType, testCode, false, true, false);
 }
 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 pos = '';
-  if (args != null) {
+  if ($notnull_bool(args != null)) {
     var argsCode = [];
     for (var i = 0;
-     i < args.get$length(); i++) {
+     $notnull_bool(i < args.get$length()); i++) {
       argsCode.add(args.values.$index(i).code);
     }
-    pos = Strings.join(argsCode, ", ");
+    pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), false, true, false), new Value(world.listType, ('[' + pos + ']'), false, true, false)];
   return this._tryResolveMember(context, 'noSuchMethod').invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 410, 12);
+  $assert(!args.get$hasNames(), "!args.hasNames", "value.dart", 411, 12);
   var argsString = args.getCode();
-  if (name == '\$index' || name == '\$setindex') {
+  if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
-    if (argsString.length > 0) argsString = (', ' + argsString + '');
+    if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
-Value.prototype.get_$3 = Value.prototype.get_;
+Value.prototype.get_$3 = function($0, $1, $2) {
+  return this.get_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()));
+}
+;
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
-  return this.invoke($0, $1, $2, $3, false);
+  return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), false);
 }
 ;
 Value.prototype.set_$4 = function($0, $1, $2, $3) {
-  return this.set_($0, $1, $2, $3, false);
+  return this.set_(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type0, actualValue, canonicalCode, original, code0) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   this.original = original;
   Value.call(this, type0, code0, false, false, false);
   // Initializers done
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type0, actualValue0, canonicalCode0, original0) {
-  return new EvaluatedValue._internal$ctor(type0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
+  return new EvaluatedValue._internal$ctor(type0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments($assert_String(canonicalCode0), (original0 && original0.is$SourceSpan())));
 }
 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.codeWithComments = function(canonicalCode0, original0) {
-  return (original0 != null && original0.get$text() != canonicalCode0) ? ('' + canonicalCode0 + '/*' + original0.get$text() + '*/') : canonicalCode0;
+  return $notnull_bool((original0 != null && original0.get$text() != canonicalCode0)) ? ('' + canonicalCode0 + '/*' + original0.get$text() + '*/') : canonicalCode0;
 }
 // ********** Code for ConstListValue **************
 function ConstListValue() {}
 ConstListValue._internal$ctor = function(type0, values, actualValue0, canonicalCode0, original0, code0) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
 ConstListValue.ConstListValue$factory = function(type0, values0, actualValue0, canonicalCode0, original0) {
   return new ConstListValue._internal$ctor(type0, values0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type0, values, actualValue0, canonicalCode0, original0, code0) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type0, keyValuePairs, actualValue0, canonicalCode0, original0) {
   var values0 = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
-   i < keyValuePairs.length; i += 2) {
+   $notnull_bool(i < keyValuePairs.length); i += 2) {
     values0.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type0, values0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type0, fields, actualValue0, canonicalCode0, original0, code0) {
   this.fields = fields;
   EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
 $inherits(ConstObjectValue, EvaluatedValue);
 ConstObjectValue.ConstObjectValue$factory = function(type0, fields0, canonicalCode0, original0) {
+  var $0;
   var fieldValues = [];
   var $list = fields0.getKeys();
   for (var $i = fields0.getKeys().iterator(); $i.hasNext(); ) {
     var f = $i.next();
     fieldValues.add(('' + f + ' = ' + fields0.$index(f).get$actualValue() + ''));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo(b);
   })
   );
   var actualValue0 = ('const ' + type0.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
   return new ConstObjectValue._internal$ctor(type0, fields0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for GlobalValue **************
 function GlobalValue(type0, code0, isConst0, field, name, exp, canonicalCode, original, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.original = original;
   this.dependencies = dependencies;
   Value.call(this, type0, code0, false, !isConst0, false);
   // Initializers done
 }
 $inherits(GlobalValue, Value);
 GlobalValue.GlobalValue$fromStatic$factory = function(field0, exp0, dependencies0) {
-  var code0 = (exp0.get$isConst() ? exp0.canonicalCode : exp0.code);
+  var code0 = ($notnull_bool(exp0.get$isConst()) ? exp0.canonicalCode : exp0.code);
   var codeWithComment = ('' + code0 + '/*' + field0.declaringType.name + '.' + field0.get$name() + '*/');
   return new GlobalValue(exp0.type, codeWithComment, field0.isFinal, field0, null, exp0, code0, null, dependencies0.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
 GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp0, dependencies0) {
   var name0 = ("const\$" + uniqueId + "");
   var codeWithComment = ("" + name0 + "/*" + exp0.original.get$text() + "*/");
   return new GlobalValue(exp0.type, codeWithComment, true, null, name0, exp0, name0, exp0.original, dependencies0.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
 GlobalValue.prototype.get$isConst = function() {
   return this.exp.get$isConst() && (this.field == null || this.field.isFinal);
 }
 GlobalValue.prototype.get$actualValue = function() {
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
-  if ($eq(other, this)) {
+  if ($notnull_bool($eq(other, this))) {
     return 0;
   }
-  else if (this.dependencies.indexOf(other, 0) >= 0) {
+  else if ($notnull_bool(this.dependencies.indexOf(other, 0) >= 0)) {
     return 1;
   }
-  else if (other.dependencies.indexOf(this, 0) >= 0) {
+  else if ($notnull_bool(other.dependencies.indexOf(this, 0) >= 0)) {
     return -1;
   }
-  else if (this.dependencies.length > other.dependencies.length) {
+  else if ($notnull_bool(this.dependencies.length > other.dependencies.length)) {
     return 1;
   }
-  else if (this.dependencies.length < other.dependencies.length) {
+  else if ($notnull_bool(this.dependencies.length < other.dependencies.length)) {
     return -1;
   }
-  else if (this.name == null && other.name != null) {
+  else if ($notnull_bool(this.name == null && other.name != null)) {
     return 1;
   }
-  else if (this.name != null && other.name == null) {
+  else if ($notnull_bool(this.name != null && other.name == null)) {
     return -1;
   }
-  else if (this.name != null) {
+  else if ($notnull_bool(this.name != null)) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for CompilerException **************
 function CompilerException(_message, _location) {
   this._lang_message = _message;
   this._location = _location;
   // Initializers done
 }
 CompilerException.prototype.toString = function() {
-  if (this._location != null) {
+  if ($notnull_bool(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 10 matching lines @@
 }
 World.prototype.get$coreimpl = function() {
   return this.libraries.$index('dart:coreimpl');
 }
 World.prototype.get$dom = function() {
   return this.libraries.$index('dart:dom');
 }
 World.prototype.get$functionType = function() { return this.functionType; };
 World.prototype.set$functionType = function(value) { return this.functionType = value; };
 World.prototype.init = function() {
+  var $0;
   this.corelib = new Library(this.readFile('dart:core'));
   this.libraries.$setindex('dart:core', this.corelib);
   this._todo.add(this.corelib);
-  this.voidType = this._addToCoreLib('void', false);
-  this.dynamicType = this._addToCoreLib('Dynamic', false);
+  this.voidType = (($0 = this._addToCoreLib('void', false)) && $0.is$lang_Type());
+  this.dynamicType = (($0 = this._addToCoreLib('Dynamic', false)) && $0.is$lang_Type());
   this.varType = this.dynamicType;
-  this.objectType = this._addToCoreLib('Object', true);
-  this.numType = this._addToCoreLib('num', false);
-  this.boolType = this._addToCoreLib('bool', false);
-  this.stringType = this._addToCoreLib('String', false);
-  this.listType = this._addToCoreLib('List', false);
-  this.mapType = this._addToCoreLib('Map', false);
-  this.functionType = this._addToCoreLib('Function', false);
+  this.objectType = (($0 = this._addToCoreLib('Object', true)) && $0.is$lang_Type());
+  this.numType = (($0 = this._addToCoreLib('num', false)) && $0.is$lang_Type());
+  this.intType = (($0 = this._addToCoreLib('int', false)) && $0.is$lang_Type());
+  this.doubleType = (($0 = this._addToCoreLib('double', false)) && $0.is$lang_Type());
+  this.boolType = (($0 = this._addToCoreLib('bool', false)) && $0.is$lang_Type());
+  this.stringType = (($0 = this._addToCoreLib('String', false)) && $0.is$lang_Type());
+  this.listType = (($0 = this._addToCoreLib('List', false)) && $0.is$lang_Type());
+  this.mapType = (($0 = this._addToCoreLib('Map', false)) && $0.is$lang_Type());
+  this.functionType = (($0 = this._addToCoreLib('Function', false)) && $0.is$lang_Type());
 }
 World.prototype._addMember = function(member) {
-  if (member.get$isStatic()) {
-    if (member.declaringType.get$isTop()) {
+  $assert(!member.get$isPrivate(), "!member.isPrivate", "world.dart", 141, 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 (mset == null) {
+  if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member);
     this._members.$setindex(mset.get$name(), mset);
   }
   else {
     mset.members.add(member);
   }
 }
 World.prototype._addTopName = function(named) {
   var existing = this._topNames.$index(named.get$name());
-  if ($ne(existing, null)) {
+  if ($notnull_bool($ne(existing, null))) {
     this.info(('mangling matching top level name "' + named.get$name() + '" in ') + ('both "' + named.get$library().name + '" and "' + existing.get$library().name + '"'));
-    if (named.get$isNative()) {
-      if (existing.get$isNative()) {
+    if ($notnull_bool(named.get$isNative())) {
+      if ($notnull_bool(existing.get$isNative())) {
         world.internalError(('conflicting native names "' + named.get$name() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
       }
       else {
         this._topNames.$setindex(named.get$name(), named);
-        this._addJavascriptTopName(existing);
+        this._addJavascriptTopName((existing && existing.is$Named()));
       }
     }
-    else if (named.get$library().get$isCore()) {
-      if (existing.get$library().get$isCore()) {
+    else if ($notnull_bool(named.get$library().get$isCore())) {
+      if ($notnull_bool(existing.get$library().get$isCore())) {
         world.internalError(('conflicting top-level names in core "' + named.get$name() + '" ') + ('(previously defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
       }
       else {
         this._topNames.$setindex(named.get$name(), named);
-        this._addJavascriptTopName(existing);
+        this._addJavascriptTopName((existing && existing.is$Named()));
       }
     }
     else {
       this._addJavascriptTopName(named);
     }
   }
   else {
     this._topNames.$setindex(named.get$name(), named);
   }
 }
 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 ($ne(existing, null) && $ne(existing, named)) {
+  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 (!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 (this._jsKeywords == null) {
+  if ($notnull_bool(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 (this._jsKeywords.contains(name)) {
+  if ($notnull_bool(this._jsKeywords.contains(name))) {
     return name + '_';
   }
   else {
     return name;
   }
 }
 World.prototype.compile = function() {
-  if (options.dartScript == null) {
+  if ($notnull_bool(options.dartScript == null)) {
     this.fatal('no script provided to compile');
     return false;
   }
   try {
     this.info(('compiling ' + options.dartScript + ' with corelib ' + this.corelib + ''));
-    if (!this.runLeg()) this.runCompilationPhases();
+    if ($notnull_bool(!this.runLeg())) this.runCompilationPhases();
   } catch (exc) {
     exc = $toDartException(exc);
-    if (this.get$hasErrors() && !options.throwOnErrors) {
+    if ($notnull_bool(this.get$hasErrors() && !options.throwOnErrors)) {
     }
     else {
       throw exc;
     }
   }
   this.printStatus();
   return !this.get$hasErrors();
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
-  if (!options.enableLeg) return false;
+  if ($notnull_bool(!options.enableLeg)) return false;
   var res = this.withTiming('try leg compile', (function () {
     return compile($this);
   })
   );
-  if (!res && options.legOnly) {
+  if ($notnull_bool(!res && options.legOnly)) {
     this.fatal(("Leg could not compile " + options.dartScript + ""));
   }
   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 $0;
     var mainMembers = lib.topType.resolveMember('main');
     var main = null;
-    if (mainMembers == null || mainMembers.members.length == 0) {
+    if ($notnull_bool(mainMembers == null || mainMembers.members.length == 0)) {
       $this.fatal('no main method specified');
     }
-    else if (mainMembers.members.length > 1) {
+    else if ($notnull_bool(mainMembers.members.length > 1)) {
       var $list = mainMembers.members;
       for (var $i = mainMembers.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.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 (this.legCode != null) {
+  if ($notnull_bool(this.legCode != null)) {
+    $assert(options.enableLeg, "options.enableLeg", "world.dart", 304, 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 library = this.libraries.$index(filename);
-  if (library == null) {
+  if ($notnull_bool(library == null)) {
     library = new Library(this.readFile(filename));
     this.info(('read library ' + filename + ''));
-    if (!library.get$isCore()) {
+    if ($notnull_bool(!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 (this._todo.length > 0) {
+  while ($notnull_bool(this._todo.length > 0)) {
     var todo = this._todo;
     this._todo = [];
     for (var $i = 0;$i < todo.length; $i++) {
       var lib = todo.$index($i);
       new LibraryVisitor(lib);
     }
   }
 }
 World.prototype.processScript = function(filename) {
   var library = this.getOrAddLibrary(filename);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
+  var $0;
   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, throwing) {
   var text = message;
-  if (span != null) {
+  if ($notnull_bool(span != null)) {
     text = span.toMessageString(message);
   }
   print(text);
-  if (span1 != null) {
+  if ($notnull_bool(span1 != null)) {
     print(span1.toMessageString(message));
   }
-  if (throwing) {
+  if ($notnull_bool(throwing)) {
     $throw(new CompilerException(message, span));
   }
 }
 World.prototype.error = function(message, span, span1) {
   this.errors++;
   this._message(('error: ' + message + ''), span, span1, options.throwOnErrors);
 }
 World.prototype.warning = function(message, span, span1) {
   this.warnings++;
-  if (options.showWarnings) {
+  if ($notnull_bool(options.showWarnings)) {
     this._message(('warning: ' + message + ''), span, span1, options.throwOnWarnings);
   }
 }
 World.prototype.fatal = function(message, span, span1) {
   this.errors++;
   this.seenFatal = true;
-  this._message(('fatal: ' + message + ''), span, span1, options.throwOnFatal || options.throwOnErrors);
+  this._message(('fatal: ' + message + ''), span, span1, $assert_bool(options.throwOnFatal || options.throwOnErrors));
 }
 World.prototype.internalError = function(message, span, span1) {
   this._message(('We are sorry, but... ' + message + ''), span, span1, true);
 }
 World.prototype.info = function(message, span, span1) {
-  if (options.showInfo) {
+  if ($notnull_bool(options.showInfo)) {
     this._message(('info: ' + message + ''), span, span1, false);
   }
 }
 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 (this.get$hasErrors()) {
+  if ($notnull_bool(this.get$hasErrors())) {
     print(('compilation failed with ' + this.errors + ' errors'));
   }
   else {
-    if (this.warnings > 0) {
+    if ($notnull_bool(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();
   var result = f();
   sw.stop();
   this.info(('' + name + ' in ' + sw.elapsedInMs() + 'msec'));
   return result;
 }
 // ********** Code for FrogOptions **************
 function FrogOptions(homedir, args, files) {
+  var $0;
   this.enableLeg = false
   this.legOnly = false
   this.enableAsserts = false
   this.enableTypeChecks = false
   this.verifyImplements = false
   this.compileAll = false
   this.dietParse = false
   this.compileOnly = false
   this.throwOnErrors = false
   this.throwOnWarnings = false
   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;
-   i < args.length; i++) {
+   $notnull_bool(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 46 matching lines @@
         this.throwOnWarnings = true;
         continue loop;
 
       case '--compile-only':
 
         this.compileOnly = true;
         continue loop;
 
       default:
 
-        if (arg.endsWith('.dart')) {
-          this.dartScript = arg;
-          this.childArgs = args.getRange(i + 1, args.length - i - 1);
+        if ($notnull_bool(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 (arg.startsWith('--out=')) {
+        else if ($notnull_bool(arg.startsWith('--out='))) {
           this.outfile = arg.substring('--out='.length);
         }
-        else if (arg.startsWith('--libdir=')) {
+        else if ($notnull_bool(arg.startsWith('--libdir='))) {
           this.libDir = arg.substring('--libdir='.length);
           passedLibDir = true;
         }
         else {
-          if (!ignoreUnrecognizedFlags) {
+          if ($notnull_bool(!ignoreUnrecognizedFlags)) {
             print(('unrecognized flag: "' + arg + '"'));
           }
         }
 
     }
   }
-  if (!passedLibDir && !files.fileExists(this.libDir)) {
+  if ($notnull_bool(!passedLibDir && !files.fileExists(this.libDir))) {
     var temp = 'frog/lib';
-    if (files.fileExists(temp)) {
-      this.libDir = temp;
+    if ($notnull_bool(files.fileExists(temp))) {
+      this.libDir = $assert_String(temp);
     }
     else {
       this.libDir = 'lib';
     }
   }
 }
 // ********** Code for LibraryReader **************
 function LibraryReader() {
   // Initializers done
   this._specialLibs = $map(['dart:core', joinPaths(options.libDir, 'corelib.dart'), 'dart:coreimpl', joinPaths(options.libDir, 'corelib_impl.dart'), 'dart:html', joinPaths(options.libDir, '../../client/html/release/html.dart'), 'dart:dom', joinPaths(options.libDir, 'dom/dom.dart'), 'dart:json', joinPaths(options.libDir, 'json.dart')]);
 }
 LibraryReader.prototype.readFile = function(fullname) {
   var filename = this._specialLibs.$index(fullname);
-  if (filename == null) {
+  if ($notnull_bool(filename == null)) {
     filename = fullname;
   }
-  if (world.files.fileExists(filename)) {
+  if ($notnull_bool(world.files.fileExists(filename))) {
     return new SourceFile(filename, world.files.readAll(filename));
   }
   else {
     world.error(('File not found: ' + filename + ''));
     return new SourceFile(filename, '');
   }
 }
 // ********** Code for VarMember **************
 function VarMember(name) {
   this.name = name;
   // Initializers done
 }
+VarMember.prototype.is$VarMember = function(){return this;};
 VarMember.prototype.get$name = function() { return this.name; };
 VarMember.prototype.get$returnType = function() {
   return world.varType;
 }
 VarMember.prototype.invoke = function(context, node, target, args) {
   return new Value(this.get$returnType(), ('' + target.code + '.' + this.name + '(' + args.getCode() + ')'), false, true, false);
 }
-VarMember.prototype.invoke$4 = VarMember.prototype.invoke;
+VarMember.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 VarFunctionStub **************
 function VarFunctionStub(name0, callArgs) {
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name0);
   // Initializers done
 }
 $inherits(VarFunctionStub, VarMember);
 VarFunctionStub.prototype.generate = function(code) {
-  if (this.args.get$hasNames()) {
+  if ($notnull_bool(this.args.get$hasNames())) {
     this.generateNamed(code);
   }
   else {
     this.generatePositional(code);
   }
 }
 VarFunctionStub.prototype.generatePositional = function(w) {
   var arity = this.args.get$length();
   w.enterBlock(('Function.prototype.to\$' + this.name + ' = function() {'));
   w.writeln(('this.' + this.name + ' = this.\$genStub(' + arity + ');'));
@@ skipping 17 matching lines @@
 // ********** Code for VarMethodStub **************
 function VarMethodStub(name0, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   VarMember.call(this, name0);
   // Initializers done
 }
 $inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$returnType = function() {
-  return this.member != null ? this.member.get$returnType() : world.varType;
+  return $notnull_bool(this.member != null) ? this.member.get$returnType() : world.varType;
 }
 VarMethodStub.prototype.get$typeName = function() {
-  return this.member != null ? this.member.declaringType.get$jsname() : 'Object';
+  return $notnull_bool(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 (this._useDirectCall(this.member, this.args)) {
+  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(member0, args0) {
-  if ((member0 instanceof MethodMember) && $ne(member0.declaringType.get$library(), world.get$dom())) {
+  if ($notnull_bool((member0 instanceof MethodMember) && $ne(member0.declaringType.get$library(), world.get$dom()))) {
     var method = member0;
-    method.genParameterValues();
+    if ($notnull_bool(method.needsArgumentConversion(args0))) {
+      return false;
+    }
     for (var i = args0.get$length();
-     i < method.parameters.length; i++) {
-      if (method.parameters.$index(i).get$value().code != 'null') {
+     $notnull_bool(i < method.parameters.length); i++) {
+      if ($notnull_bool(method.parameters.$index(i).get$value().code != 'null')) {
         return false;
       }
     }
     return method.namesInOrder(args0);
   }
   else {
     return false;
   }
 }
 // ********** Code for VarMethodSet **************
 function VarMethodSet(name0, members, callArgs, returnType) {
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name0);
   // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
   return this.members.$index(0).get$name();
 }
 VarMethodSet.prototype.invoke = function(context, node, target, args0) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args0);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
-  if (this._fallbackStubs != null) return;
+  if ($notnull_bool(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', false, true, false);
     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 ($ne(type.get$library(), world.get$dom()) && !type.get$isObject()) {
-      VarMethodSet._addVarStub(type, stub);
+    if ($notnull_bool($ne(type.get$library(), world.get$dom()) && !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', false, true, false);
   var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
   var stub = new VarMethodStub(this.name, null, this.args, result);
-  if (this._fallbackStubs.length == 0) {
-    VarMethodSet._addVarStub(world.objectType, stub);
+  if ($notnull_bool(this._fallbackStubs.length == 0)) {
+    VarMethodSet._addVarStub(world.objectType, (stub && stub.is$VarMember()));
   }
   else {
     this._fallbackStubs.add(stub);
   }
 }
 VarMethodSet._addVarStub = function(type, stub) {
-  if (type.varStubs == null) type.varStubs = $map([]);
+  if ($notnull_bool(type.varStubs == null)) type.varStubs = $map([]);
   type.varStubs.$setindex(stub.name, stub);
 }
 VarMethodSet.prototype.generate = function(code) {
-  if (this._fallbackStubs.length == 0) return;
+  if ($notnull_bool(this._fallbackStubs.length == 0)) return;
   code.enterBlock(('\$varMethod("' + this.name + '", {'));
   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(',');
   }
   code.exitBlock('});');
 }
-VarMethodSet.prototype.invoke$4 = VarMethodSet.prototype.invoke;
+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 $0;
   var result = new ListFactory();
-  if (!!(source && source.is$List)) {
+  if ($notnull_bool(!!(source && source.is$List))) {
     var list = source;
     result.length = list.length;
     for (var i = 0;
-     i < list.length; i++) {
+     $notnull_bool(i < list.length); i++) {
       result.$setindex(i, mapper.call$1(list.$index(i)));
     }
   }
   else {
     for (var $i = source.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       result.add(mapper.call$1(item));
     }
   }
   return result;
 }
 function reduce(source, callback, initialValue) {
   var i = source.iterator();
   var current = initialValue;
-  if (current == null && i.hasNext()) {
+  if ($notnull_bool(current == null && i.hasNext())) {
     current = i.next();
   }
-  while (i.hasNext()) {
+  while ($notnull_bool(i.hasNext())) {
     current = callback.call$2(current, i.next());
   }
   return current;
 }
 function orderValuesByKeys(map0) {
+  var $0;
   var keys = map0.getKeys();
   keys.sort((function (x, y) {
     return x.compareTo(y);
   })
   );
   var values = [];
   for (var $i = keys.iterator(); $i.hasNext(); ) {
     var k = $i.next();
     values.add(map0.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
   return text.startsWith('"""') || text.startsWith("'''");
 }
 function isRawMultilineString(text) {
   return text.startsWith('@"""') || text.startsWith("@'''");
 }
 function parseStringLiteral(lit) {
-  if (lit.startsWith('@')) {
-    if (isRawMultilineString(lit)) {
+  if ($notnull_bool(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 (isMultilineString(lit)) {
+  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 (text.startsWith('\n')) {
+  if ($notnull_bool(text.startsWith('\n'))) {
     return text.substring(1);
   }
-  else if (text.startsWith('\r')) {
-    if (text.startsWith('\r\n')) {
+  else if ($notnull_bool(text.startsWith('\r'))) {
+    if ($notnull_bool(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 (options.outfile != null) {
-    if (success) {
+  if ($notnull_bool(options.outfile != null)) {
+    if ($notnull_bool(success)) {
       var code = world.getGeneratedCode();
-      if (!options.outfile.endsWith('.js')) {
+      if ($notnull_bool(!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 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();
-   i < args.get$length(); i++) {
+   $notnull_bool(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(process.argv.$index(1)));
-  if (lang_compile(homedir, process.argv, new NodeFileSystem())) {
+  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 (!options.compileOnly) {
-      process.argv = [process.argv.$index(0), process.argv.$index(1)];
+    if ($notnull_bool(!options.compileOnly)) {
+      process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll(options.childArgs);
-      get$vm().runInNewContext(code, createSandbox());
+      get$vm().runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
 }
 Function.prototype.to$call$0 = function() {
   this.call$0 = this.$genStub(0);
   this.to$call$0 = function() { return this.call$0; };
   return this.call$0;
@@ skipping 13 matching lines @@
 function to$call$1(f) { return f && f.to$call$1(); }
 Function.prototype.to$call$2 = function() {
   this.call$2 = this.$genStub(2);
   this.to$call$2 = function() { return this.call$2; };
   return this.call$2;
 };
 Function.prototype.call$2 = function($0, $1) {
   return this.to$call$2()($0, $1);
 };
 function to$call$2(f) { return f && f.to$call$2(); }
-var const$1 = new StringWrapper('global scope')/*const SourceString('global scope')*/;
+var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$133 = new Keyword("break", false)/*const Keyword("break")*/;
 var const$135 = new Keyword("case", false)/*const Keyword("case")*/;
 var const$137 = new Keyword("catch", false)/*const Keyword("catch")*/;
 var const$139 = new Keyword("const", false)/*const Keyword("const")*/;
 var const$141 = new Keyword("continue", false)/*const Keyword("continue")*/;
 var const$143 = new Keyword("default", false)/*const Keyword("default")*/;
 var const$145 = new Keyword("do", false)/*const Keyword("do")*/;
 var const$147 = new Keyword("else", false)/*const Keyword("else")*/;
 var const$149 = new Keyword("false", false)/*const Keyword("false")*/;
 var const$151 = new Keyword("final", false)/*const Keyword("final")*/;
@@ skipping 14 matching lines @@
 var const$181 = new Keyword("var", false)/*const Keyword("var")*/;
 var const$183 = new Keyword("void", false)/*const Keyword("void")*/;
 var const$185 = new Keyword("while", false)/*const Keyword("while")*/;
 var const$187 = new Keyword("abstract", true)/*const Keyword("abstract", true)*/;
 var const$189 = new Keyword("assert", true)/*const Keyword("assert", true)*/;
 var const$191 = new Keyword("class", true)/*const Keyword("class", true)*/;
 var const$193 = new Keyword("extends", true)/*const Keyword("extends", true)*/;
 var const$195 = new Keyword("factory", true)/*const Keyword("factory", true)*/;
 var const$197 = new Keyword("get", true)/*const Keyword("get", true)*/;
 var const$199 = new Keyword("implements", true)/*const Keyword("implements", true)*/;
-var const$2 = new StringWrapper('main')/*const SourceString('main')*/;
+var const$2 = new StringWrapper('global scope')/*const SourceString('global scope')*/;
 var const$201 = new Keyword("import", true)/*const Keyword("import", true)*/;
 var const$203 = new Keyword("interface", true)/*const Keyword("interface", true)*/;
 var const$205 = new Keyword("library", true)/*const Keyword("library", true)*/;
 var const$207 = new Keyword("native", true)/*const Keyword("native", true)*/;
 var const$209 = new Keyword("negate", true)/*const Keyword("negate", true)*/;
 var const$211 = new Keyword("operator", true)/*const Keyword("operator", true)*/;
 var const$213 = new Keyword("set", true)/*const Keyword("set", true)*/;
 var const$215 = new Keyword("source", true)/*const Keyword("source", true)*/;
 var const$217 = new Keyword("static", true)/*const Keyword("static", true)*/;
 var const$219 = new Keyword("typedef", true)/*const Keyword("typedef", true)*/;
@@ skipping 34 matching lines @@
 var const$259 = new StringWrapper("-")/*const SourceString("-")*/;
 var const$260 = new StringWrapper("*")/*const SourceString("*")*/;
 var const$261 = new StringWrapper("/")/*const SourceString("/")*/;
 var const$262 = new StringWrapper("~/")/*const SourceString("~/")*/;
 var const$265 = new ExceptionImplementation("Internal Error (Leg): UNREACHABLE")/*const Exception("Internal Error (Leg): UNREACHABLE")*/;
 var const$266 = new StringWrapper('\$add')/*const SourceString('\$add')*/;
 var const$267 = new StringWrapper('\$div')/*const SourceString('\$div')*/;
 var const$268 = new StringWrapper('\$mul')/*const SourceString('\$mul')*/;
 var const$269 = new StringWrapper('\$sub')/*const SourceString('\$sub')*/;
 var const$270 = new StringWrapper('\$tdiv')/*const SourceString('\$tdiv')*/;
-var const$392 = ImmutableList.ImmutableList$from$factory(['NullPointerException', 'ObjectNotClosureException', 'NoSuchMethodException', 'StackOverflowException'])/*const [
+var const$3 = new StringWrapper('main')/*const SourceString('main')*/;
+var const$393 = ImmutableList.ImmutableList$from$factory(['NullPointerException', 'ObjectNotClosureException', 'NoSuchMethodException', 'StackOverflowException'])/*const [
       'NullPointerException', 'ObjectNotClosureException',
       'NoSuchMethodException', 'StackOverflowException']*/;
-var const$4 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$5 = new EmptyQueueException()/*const EmptyQueueException()*/;
 HTracer._singleton = null;
 var const$222 = ImmutableList.ImmutableList$from$factory([const$133, const$135, const$137, const$139, const$141, const$143, const$145, const$147, const$149, const$151, const$153, const$155, const$157, const$159, const$161, const$163, const$165, const$167, const$169, const$171, const$173, const$175, const$177, const$179, const$181, const$183, const$185, const$187, const$189, const$191, const$193, const$195, const$197, const$199, const$201, const$203, const$205, const$207, const$209, const$211, const$213, const$215, const$217, const$219])/*const <Keyword> [
       BREAK,
       CASE,
       CATCH,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
@@ skipping 28 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();