Adds typechecking of return values

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 91 matching lines @@
       res = new StackOverflowException();
     }
   }
   // TODO(jmesserly): setting the stack property is not a long term solution.
   // Also it causes the exception to print as if it were a TypeError or
   // RangeError, instead of using the proper toString.
   res.stack = e.stack;
   return res;
 }
 function $notnull_bool(test) {
-  if (test == null || typeof(test) != 'boolean') {
-    $throw(new TypeError('must be "true" or "false"'));
-  }
-  return test === true;
+  return typeof(test) == 'boolean' ? test : test.is$bool();

[Siggi Cherem (dart-lang), 2011/11/11 08:23:53]

I couldn't find, where is 'is$bool()' generated?

 }
 function $assert(test, text, url, line, column) {
   if (typeof test == 'function') test = test();
   if (!test) $throw(new AssertError(text, url, line, column));
 }
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
@@ skipping 762 matching lines @@
     return _IsolateJsUtil._deserializeMessage(message_);
   } else {
     // Nothing more to do.
     return message_;
   }
 }
 
 function _IsolateJsUtil() {}
 // ********** Code for ListFactory **************
 ListFactory = Array;
+ListFactory.prototype.is$ListFactory = function(){return this;};
 ListFactory.prototype.is$List = function(){return this;};
 ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
+ListFactory.prototype.is$List$Definition = function(){return this;};
 ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
 ListFactory.prototype.is$List$String = function(){return this;};
 ListFactory.prototype.is$List$T = function(){return this;};
 ListFactory.prototype.is$List$Type = function(){return this;};
 ListFactory.prototype.is$List$Value = function(){return this;};
 ListFactory.prototype.is$List$int = function(){return this;};
 ListFactory.prototype.is$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;
+  return (list && list.is$ListFactory());
 }
 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(); ) {
@@ skipping 33 matching lines @@
 ListFactory$Type = ListFactory;
 ListFactory$V = ListFactory;
 ListFactory$ValueSetNode = ListFactory;
 ListFactory$int = ListFactory;
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
+ListIterator.prototype.is$Iterator$T = function(){return this;};
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
@@ skipping 64 matching lines @@
 }
 // ********** Code for ImmutableMap **************
 function ImmutableMap(keyValuePairs) {
   this._internal = $map([]);
   // Initializers done
   for (var i = 0;
    $notnull_bool(i < keyValuePairs.length); i += 2) {
     this._internal.$setindex(keyValuePairs.$index(i), keyValuePairs.$index(i + 1));
   }
 }
+ImmutableMap.prototype.is$Map$Node$Element = function(){return this;};
+ImmutableMap.prototype.is$Map$String$Member = function(){return this;};
 ImmutableMap.prototype.$index = function(key) {
   return this._internal.$index(key);
 }
 ImmutableMap.prototype.isEmpty = function() {
   return this._internal.isEmpty();
 }
 ImmutableMap.prototype.get$length = function() {
   return this._internal.get$length();
 }
 Object.defineProperty(ImmutableMap.prototype, "length", {
@@ skipping 17 matching lines @@
 // ********** Code for MatchImplementation **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
   this._start = _start;
   this._end = _end;
   this._groups = _groups;
   // Initializers done
 }
 MatchImplementation.prototype.$index = function(group) {
-  return this._groups.$index(group);
+  return $assert_String(this._groups.$index(group));
 }
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.isNaN = function() {
   return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   return this == 0 ? (1 / this) < 0 : this < 0;
 }
 NumImplementation.prototype.hashCode = function() {
@@ skipping 53 matching lines @@
   // Initializers done
   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$HashMapImplementation = function(){return this;};
+HashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
+HashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
-  return result;
+  return (result && result.is$HashMapImplementation());
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
@@ skipping 146 matching lines @@
   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$Node$Element = function(){return this;};
+HashMapImplementation$E$E.prototype.is$Map$String$Member = function(){return this;};
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
   return hashCode & (length - 1);
 }
 HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
   return (currentProbe + numberOfProbes) & (length - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
@@ skipping 125 matching lines @@
   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$Element$HInstruction, HashMapImplementation);
+HashMapImplementation$Element$HInstruction.prototype.is$Map$Node$Element = false;
+HashMapImplementation$Element$HInstruction.prototype.is$Map$String$Member = false;
 HashMapImplementation$Element$HInstruction.HashMapImplementation$from$factory = function(other) {
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
-  return result;
+  return (result && result.is$HashMapImplementation());
 }
 HashMapImplementation$Element$HInstruction._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V **************
 function HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$K$V(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V, HashMapImplementation);
+HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$Node$Element = false;
+HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V.prototype.is$Map$String$Member = false;
 HashMapImplementation$K$DoubleLinkedQueueEntry$KeyValuePair$K$V._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element **************
 function HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$Node$Element(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element, HashMapImplementation);
+HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$Node$Element = false;
+HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element.prototype.is$Map$String$Member = false;
 HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword **************
 function HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword, HashMapImplementation);
+HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$Node$Element = false;
+HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$DoubleLinkedQueueEntry$KeyValuePair$String$Keyword._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$EvaluatedValue **************
 function HashMapImplementation$String$EvaluatedValue() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$EvaluatedValue(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$EvaluatedValue, HashMapImplementation);
+HashMapImplementation$String$EvaluatedValue.prototype.is$Map$Node$Element = false;
+HashMapImplementation$String$EvaluatedValue.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$EvaluatedValue._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$String$String **************
 function HashMapImplementation$String$String() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$String(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$String$String, HashMapImplementation);
+HashMapImplementation$String$String.prototype.is$Map$Node$Element = false;
+HashMapImplementation$String$String.prototype.is$Map$String$Member = false;
 HashMapImplementation$String$String._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$Type$Type **************
 function HashMapImplementation$Type$Type() {
   // Initializers done
   if ($notnull_bool(HashMapImplementation._deletedKey == null)) {
     HashMapImplementation._deletedKey = new Object();
   }
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$Type(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$Type$Type, HashMapImplementation);
+HashMapImplementation$Type$Type.prototype.is$Map$Node$Element = false;
+HashMapImplementation$Type$Type.prototype.is$Map$String$Member = false;
 HashMapImplementation$Type$Type._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashMapImplementation$int$int **************
 function HashMapImplementation$int$int() {
   // Initializers done
   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$int(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$int$int, HashMapImplementation);
+HashMapImplementation$int$int.prototype.is$Map$Node$Element = false;
+HashMapImplementation$int$int.prototype.is$Map$String$Member = false;
 HashMapImplementation$int$int._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
+HashSetImplementation.prototype.is$HashSetImplementation = function(){return this;};
 HashSetImplementation.prototype.is$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;
+  return (set && set.is$HashSetImplementation());
 }
 HashSetImplementation.prototype.clear = function() {
   this._backingMap.clear();
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
 HashSetImplementation.prototype.contains = function(value) {
   return this._backingMap.containsKey(value);
 }
@@ skipping 67 matching lines @@
 }
 $inherits(HashSetImplementation$int, HashSetImplementation);
 HashSetImplementation$int.prototype.is$Iterable = function(){return this;};
 // ********** Code for HashSetIterator **************
 function HashSetIterator(set_) {
   this._nextValidIndex = -1;
   this._entries = set_._backingMap._keys;
   // Initializers done
   this._advance();
 }
+HashSetIterator.prototype.is$Iterator$T = function(){return this;};
 HashSetIterator.prototype.hasNext = function() {
   if ($notnull_bool(this._nextValidIndex >= this._entries.length)) return false;
   if ($notnull_bool(this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey)) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
   if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
     $throw(const$0/*const NoMoreElementsException()*/);
@@ skipping 13 matching lines @@
   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.is$Iterator$T = function(){return this;};
 HashSetIterator$E.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
   do {
     if ($notnull_bool(++this._nextValidIndex >= length)) break;
     entry = this._entries.$index(this._nextValidIndex);
   }
   while ($notnull_bool((entry == null) || (entry === deletedKey)))
 }
@@ skipping 17 matching lines @@
 $inherits(KeyValuePair$Node$Element, 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$Node$Element = function(){return this;};
+LinkedHashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
   if ($notnull_bool(this._map.containsKey(key))) {
     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) {
@@ skipping 40 matching lines @@
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
 // ********** Code for LinkedHashMapImplementation$Node$Element **************
 function LinkedHashMapImplementation$Node$Element() {
   // Initializers done
   this._map = new HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element();
   this._list = new DoubleLinkedQueue$KeyValuePair$Node$Element();
 }
 $inherits(LinkedHashMapImplementation$Node$Element, LinkedHashMapImplementation);
+LinkedHashMapImplementation$Node$Element.prototype.is$Map$Node$Element = function(){return this;};
+LinkedHashMapImplementation$Node$Element.prototype.is$Map$String$Member = false;
 // ********** 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$Node$Element = false;
+LinkedHashMapImplementation$String$Keyword.prototype.is$Map$String$Member = false;
 // ********** Code for DoubleLinkedQueueEntry **************
 function DoubleLinkedQueueEntry(e) {
   // Initializers done
   this._element = e;
 }
 DoubleLinkedQueueEntry.prototype.is$DoubleLinkedQueueEntry$KeyValuePair$K$V = function(){return this;};
 DoubleLinkedQueueEntry.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
@@ skipping 110 matching lines @@
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V.prototype._link = function(p, n) {
   this._next = n;
   this._previous = p;
   p._next = this;
   n._previous = this;
 }
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V.prototype.prepend = function(e) {
   new DoubleLinkedQueueEntry$KeyValuePair$K$V(e)._link(this._previous, this);
 }
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$K$V.prototype.previousEntry = function() {
-  return this._previous._asNonSentinelEntry();
+  var $0;
+  return (($0 = this._previous._asNonSentinelEntry()) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
 }
 // ********** Code for _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element **************
 function _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element() {
   DoubleLinkedQueueEntry$E.call(this, null);
   // Initializers done
   this._link(this, this);
 }
 $inherits(_DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element, _DoubleLinkedQueueEntrySentinel);
 _DoubleLinkedQueueEntrySentinel$KeyValuePair$Node$Element.prototype._link = function(p, n) {
   this._next = n;
@@ skipping 12 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$DoubleLinkedQueue = function(){return this;};
 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;
+  return (list && list.is$DoubleLinkedQueue());
 }
 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(); ) {
@@ skipping 15 matching lines @@
   this.forEach(function _(element) {
     counter++;
   }
   );
   return counter;
 }
 Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
   get: DoubleLinkedQueue.prototype.get$length
 });
 DoubleLinkedQueue.prototype.isEmpty = function() {
-  return (this._sentinel._next === this._sentinel);
+  return $assert_bool((this._sentinel._next === this._sentinel));
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while ($notnull_bool(entry !== this._sentinel)) {
     f(entry._element);
     entry = entry._next;
   }
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
@@ skipping 60 matching lines @@
 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;
+  return (list && list.is$DoubleLinkedQueue());
 }
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
+_DoubleLinkedQueueIterator.prototype.is$Iterator$T = function(){return this;};
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
-  return this._currentEntry._next !== this._sentinel;
+  return $assert_bool(this._currentEntry._next !== this._sentinel);
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
   if ($notnull_bool(!$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);
+_DoubleLinkedQueueIterator$E.prototype.is$Iterator$T = function(){return this;};
 // ********** Code for StopWatchImplementation **************
 function StopWatchImplementation() {
   this._start = null;
   this._stop = null;
   // Initializers done
 }
 StopWatchImplementation.prototype.start = function() {
   if ($notnull_bool(this._start == null)) {
     this._start = Clock.now();
   }
@@ skipping 52 matching lines @@
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new ListFactory$String();
   this._length = 0;
   return this;
 }
 StringBufferImpl.prototype.toString = function() {
   if ($notnull_bool(this._buffer.length == 0)) return "";
-  if ($notnull_bool(this._buffer.length == 1)) return this._buffer.$index(0);
+  if ($notnull_bool(this._buffer.length == 1)) return $assert_String(this._buffer.$index(0));
   var result = StringBase.concatAll(this._buffer);
   this._buffer.clear();
   this._buffer.add(result);
   return result;
 }
 // ********** Code for StringBase **************
 function StringBase() {}
 StringBase.createFromCharCodes = function(charCodes) {
   if (Object.getPrototypeOf(charCodes) !== Array.prototype) {
     var length = charCodes.length;
@@ skipping 94 matching lines @@
 DateImplementation.now$ctor = function() {
   this.timeZone = new TimeZoneImplementation.local$ctor();
   this.value = DateImplementation._now();
   // Initializers done
   this._asJs();
 }
 DateImplementation.now$ctor.prototype = DateImplementation.prototype;
 DateImplementation.prototype.get$value = function() { return this.value; };
 DateImplementation.prototype.$eq = function(other) {
   if ($notnull_bool(!$notnull_bool(((other instanceof DateImplementation))))) return false;
-  return (this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone));
+  return $assert_bool((this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone)));
 }
 DateImplementation.prototype.compareTo = function(other) {
   return this.value.compareTo(other.value);
 }
 DateImplementation.prototype.get$year = function() {
   return this.isUtc ? this._asJs().getUTCFullYear() :
       this._asJs().getFullYear();
 }
 DateImplementation.prototype.get$month = function() {
   return this.isUtc ? this._asJs().getMonth() + 1 :
@@ skipping 1083 matching lines @@
 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();
+  var $0;
+  return (($0 = this.toList().iterator()) && $0.is$Iterator$T());
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
   var $0;
   if ($notnull_bool(this.isEmpty())) return;
   buffer.add($notnull_bool(this.get$head() == null) ? 'null' : this.get$head());
   if ($notnull_bool(separatedBy == null)) separatedBy = '';
   for (var link = (($0 = this.get$tail()) && $0.is$Link());
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link())) {
     buffer.add(separatedBy);
     buffer.add($notnull_bool(link.get$head() == null) ? 'null' : link.get$head());
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
 }
 // ********** Code for AbstractLink$T **************
 function AbstractLink$T() {}
 $inherits(AbstractLink$T, AbstractLink);
 AbstractLink$T.prototype.is$Link = 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();
+  var $0;
+  return (($0 = this.toList().iterator()) && $0.is$Iterator$T());
 }
 // ********** Code for LinkTail **************
 function LinkTail() {
   // Initializers done
 }
 $inherits(LinkTail, AbstractLink$T);
 LinkTail.prototype.is$Link = 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;};
@@ skipping 1983 matching lines @@
   else {
     this.listener.handleNoType(token);
   }
   this.listener.endTypeVariable(token);
   return token;
 }
 PartialParser.prototype.get$parseTypeVariable = function() {
   return PartialParser.prototype.parseTypeVariable.bind(this);
 }
 PartialParser.prototype.optional = function(value, token) {
-  return value === token.get$stringValue();
+  return $assert_bool(value === token.get$stringValue());
 }
 PartialParser.prototype.parseType = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     token = this.parseIdentifier(token);
     while ($notnull_bool(this.optional('.', token))) {
       token = this.parseIdentifier(this.next(token));
     }
   }
   else if ($notnull_bool(this.optional('var', token))) {
     this.listener.handleVarKeyword(token);
@@ skipping 236 matching lines @@
 Parser.prototype.parseExpression = function(token) {
   token = this.parseConditionalExpression(token);
   if ($notnull_bool(this.isAssignmentOperator(token))) {
     var operator = token;
     token = this.parseExpression(this.next(token));
     this.listener.handleAssignmentExpression(operator);
   }
   return token;
 }
 Parser.prototype.isAssignmentOperator = function(token) {
-  return 2 === this.getPrecedence(token);
+  return $assert_bool(2 === this.getPrecedence(token));
 }
 Parser.prototype.parseConditionalExpression = function(token) {
   token = this.parseBinaryExpression(token, 4);
   if ($notnull_bool(this.optional('?', token))) {
     var question = token;
     token = this.parseExpression(this.next(token));
     var colon = token;
     token = this.expect(':', token);
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression(question, colon);
@@ skipping 376 matching lines @@
 function ParserTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(ParserTask, CompilerTask);
 ParserTask.prototype.get$name = function() {
   return 'Parser';
 }
 ParserTask.prototype.parse = function(element) {
   var $this = this; // closure support
-  return this.measure((function () {
+  var $0;
+  return (($0 = this.measure((function () {
     return element.parseNode($this.compiler, $this.compiler);
   })
-  );
+  )) && $0.is$Node());
 }
 // ********** Code for Listener **************
 function Listener() {}
 Listener.prototype.beginArguments = function(token) {
 
 }
 Listener.prototype.endArguments = function(count, beginToken, endToken) {
 
 }
 Listener.prototype.beginBlock = function(token) {
@@ skipping 530 matching lines @@
   this.internalString = internalString;
   this.begin = begin;
   this.end = end;
   // Initializers done
 }
 SubstringWrapper.prototype.is$SourceString = function(){return this;};
 SubstringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 SubstringWrapper.prototype.$eq = function(other) {
-  return !!(other && other.is$SourceString) && this.toString() == other.toString();
+  return $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
 }
 SubstringWrapper.prototype.printOn = function(sb) {
   sb.add(this);
 }
 SubstringWrapper.prototype.toString = function() {
   return this.internalString.substring(this.begin, this.end);
 }
 SubstringWrapper.prototype.get$stringValue = function() {
   return null;
 }
@@ skipping 50 matching lines @@
 // ********** Code for StringWrapper **************
 function StringWrapper(internalString) {
   this.internalString = internalString;
   // Initializers done
 }
 StringWrapper.prototype.is$SourceString = function(){return this;};
 StringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 StringWrapper.prototype.$eq = function(other) {
-  return !!(other && other.is$SourceString) && this.toString() == other.toString();
+  return $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
 }
 StringWrapper.prototype.printOn = function(sb) {
   sb.add(this.internalString);
 }
 StringWrapper.prototype.toString = function() {
   return this.internalString;
 }
 StringWrapper.prototype.get$stringValue = function() {
   return this.internalString;
 }
@@ skipping 17 matching lines @@
   for (var $i0 = const$230/*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();
+  return $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
 }
 Keyword.prototype.printOn = function(sb) {
   sb.add(this.syntax);
 }
 Keyword.prototype.toString = function() {
   return this.syntax;
 }
 Keyword.prototype.get$stringValue = function() {
   return this.syntax;
 }
 // ********** Code for KeywordState **************
 function KeywordState() {}
+KeywordState.prototype.is$KeywordState = function(){return this;};
 KeywordState.get$KEYWORD_STATE = function() {
   if ($notnull_bool(KeywordState._KEYWORD_STATE == null)) {
     var strings = new ListFactory$String(const$230/*Keyword.values*/.get$length());
     for (var i = 0;
      $notnull_bool(i < const$230/*Keyword.values*/.get$length()); i++) {
       strings.$setindex(i, const$230/*Keyword.values*/[i].syntax);
     }
     strings.sort((function (a, b) {
       return a.compareTo(b);
     })
@@ skipping 32 matching lines @@
 // ********** 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*/);
+  var $0;
+  return (($0 = this.table.$index(c - 97/*null.$a*/)) && $0.is$KeywordState());
 }
 ArrayKeywordState.prototype.get$keyword = function() {
   $throw("should not be called");
 }
 ArrayKeywordState.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   sb.add("[");
   var foo = this.table;
   for (var i = 0;
    $notnull_bool(i < foo.length); i++) {
@@ skipping 63 matching lines @@
   // Initializers done
 }
 $inherits(ClassNode, Node);
 ClassNode.prototype.is$ClassNode = function(){return this;};
 ClassNode.prototype.get$name = function() { return this.name; };
 ClassNode.prototype.get$interfaces = function() { return this.interfaces; };
 ClassNode.prototype.accept = function(visitor) {
   return visitor.visitClassNode(this);
 }
 ClassNode.prototype.get$isInterface = function() {
-  return this.beginToken.get$stringValue() === 'interface';
+  return $assert_bool(this.beginToken.get$stringValue() === 'interface');
 }
 ClassNode.prototype.get$isClass = function() {
   return !$notnull_bool(this.get$isInterface());
 }
 ClassNode.prototype.getBeginToken = function() {
   return this.beginToken;
 }
 ClassNode.prototype.getEndToken = function() {
   return this.endToken;
 }
@@ skipping 14 matching lines @@
 }
 $inherits(Send, Expression);
 Send.prototype.is$Send = function(){return this;};
 Send.prototype.get$arguments = function() {
   return this.argumentsNode.nodes;
 }
 Send.prototype.accept = function(visitor) {
   return visitor.visitSend(this);
 }
 Send.prototype.get$isPropertyAccess = function() {
-  return this.argumentsNode == null;
+  return $assert_bool(this.argumentsNode == null);
 }
 Send.prototype.get$isFunctionObjectInvocation = function() {
-  return this.selector == null;
+  return $assert_bool(this.selector == null);
 }
 Send.prototype.getBeginToken = function() {
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
+  var $0;
   var token;
   if ($notnull_bool(this.argumentsNode != null)) token = this.argumentsNode.getEndToken();
   if ($notnull_bool(token != null)) return token;
   if ($notnull_bool(this.selector != null)) {
-    return this.selector.getEndToken();
+    return (($0 = this.selector.getEndToken()) && $0.is$Token());
   }
-  return this.receiver.getBeginToken();
+  return (($0 = this.receiver.getBeginToken()) && $0.is$Token());
 }
 // ********** Code for SendSet **************
 function SendSet(receiver, selector, assignmentOperator, argumentsNode) {
   this.assignmentOperator = assignmentOperator;
   Send.call(this, receiver, selector, argumentsNode);
   // Initializers done
 }
 $inherits(SendSet, Send);
 SendSet.prototype.is$SendSet = function(){return this;};
 SendSet.prototype.accept = function(visitor) {
@@ skipping 17 matching lines @@
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
   if ($notnull_bool(this.beginToken != null)) return this.beginToken;
   if ($notnull_bool(this.nodes != null)) {
     for (var link = this.nodes;
      $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       if ($notnull_bool(link.get$head().getBeginToken() != null)) {
-        return link.get$head().getBeginToken();
+        return (($0 = link.get$head().getBeginToken()) && $0.is$Token());
       }
       if ($notnull_bool(link.get$head().getEndToken() != null)) {
-        return link.get$head().getEndToken();
+        return (($0 = link.get$head().getEndToken()) && $0.is$Token());
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
   var $0;
   if ($notnull_bool(this.endToken != null)) return this.endToken;
   if ($notnull_bool(this.nodes != null)) {
     var link = this.nodes;
     while ($notnull_bool(!$notnull_bool(link.get$tail().isEmpty()))) link = (($0 = link.get$tail()) && $0.is$Link$Node());
-    if ($notnull_bool(link.get$head().getEndToken() != null)) return link.get$head().getEndToken();
-    if ($notnull_bool(link.get$head().getBeginToken() != null)) return link.get$head().getBeginToken();
+    if ($notnull_bool(link.get$head().getEndToken() != null)) return (($0 = link.get$head().getEndToken()) && $0.is$Token());
+    if ($notnull_bool(link.get$head().getBeginToken() != null)) return (($0 = link.get$head().getBeginToken()) && $0.is$Token());
   }
   return this.beginToken;
 }
 // ********** Code for Block **************
 function Block(statements) {
   this.statements = statements;
   // Initializers done
 }
 $inherits(Block, Statement);
 Block.prototype.accept = function(visitor) {
   return visitor.visitBlock(this);
 }
 Block.prototype.getBeginToken = function() {
   return this.statements.getBeginToken();
 }
 Block.prototype.getEndToken = function() {
   return this.statements.getEndToken();
 }
 // ********** Code for If **************
 function If(condition, thenPart, elsePart, ifToken, elseToken) {
   this.condition = condition;
   this.thenPart = thenPart;
   this.elsePart = elsePart;
   this.ifToken = ifToken;
   this.elseToken = elseToken;
   // Initializers done
 }
 $inherits(If, Statement);
 If.prototype.get$hasElsePart = function() {
-  return this.elsePart != null;
+  return $assert_bool(this.elsePart != null);
 }
 If.prototype.accept = function(visitor) {
   return visitor.visitIf(this);
 }
 If.prototype.getBeginToken = function() {
   return this.ifToken;
 }
 If.prototype.getEndToken = function() {
   if ($notnull_bool(this.elsePart == null)) return this.thenPart.getEndToken();
   return this.elsePart.getEndToken();
@@ skipping 142 matching lines @@
   return visitor.visitLiteralBool(this);
 }
 // ********** Code for LiteralString **************
 function LiteralString(token) {
   Literal$SourceString.call(this, token, to$call$2(null));
   // Initializers done
 }
 $inherits(LiteralString, Literal$SourceString);
 LiteralString.prototype.is$LiteralString = function(){return this;};
 LiteralString.prototype.get$value = function() {
-  return this.token.get$value();
+  var $0;
+  return (($0 = this.token.get$value()) && $0.is$SourceString());
 }
 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();
+  var $0;
+  return (($0 = this.token.get$value()) && $0.is$SourceString());
 }
 Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 Identifier.prototype.getBeginToken = function() {
   return this.token;
 }
 Identifier.prototype.getEndToken = function() {
   return this.token;
 }
 // ********** Code for Operator **************
 function Operator(token) {
   Identifier.call(this, token);
   // Initializers done
 }
 $inherits(Operator, Identifier);
 Operator.prototype.is$Operator = function(){return this;};
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
 // ********** Code for Return **************
 function Return(beginToken, endToken, expression) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   this.expression = expression;
   // Initializers done
 }
 $inherits(Return, Statement);
 Return.prototype.get$hasExpression = function() {
-  return this.expression != null;
+  return $assert_bool(this.expression != null);
 }
 Return.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
 Return.prototype.getBeginToken = function() {
   return this.beginToken;
 }
 Return.prototype.getEndToken = function() {
   return this.endToken;
 }
 // ********** Code for ExpressionStatement **************
 function ExpressionStatement(expression, endToken) {
   this.expression = expression;
   this.endToken = endToken;
   // Initializers done
 }
 $inherits(ExpressionStatement, Statement);
 ExpressionStatement.prototype.is$ExpressionStatement = function(){return this;};
 ExpressionStatement.prototype.accept = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 ExpressionStatement.prototype.getBeginToken = function() {
-  return this.expression.getBeginToken();
+  var $0;
+  return (($0 = this.expression.getBeginToken()) && $0.is$Token());
 }
 ExpressionStatement.prototype.getEndToken = function() {
   return this.endToken;
 }
 // ********** Code for Throw **************
 function Throw(expression, throwToken, endToken) {
   this.expression = expression;
   this.throwToken = throwToken;
   this.endToken = endToken;
   // Initializers done
@@ skipping 13 matching lines @@
   this.typeName = typeName;
   // Initializers done
 }
 $inherits(TypeAnnotation, Node);
 TypeAnnotation.prototype.is$TypeAnnotation = function(){return this;};
 TypeAnnotation.prototype.get$typeName = function() { return this.typeName; };
 TypeAnnotation.prototype.accept = function(visitor) {
   return visitor.visitTypeAnnotation(this);
 }
 TypeAnnotation.prototype.getBeginToken = function() {
-  return this.typeName.getBeginToken();
+  var $0;
+  return (($0 = this.typeName.getBeginToken()) && $0.is$Token());
 }
 TypeAnnotation.prototype.getEndToken = function() {
-  return this.typeName.getEndToken();
+  var $0;
+  return (($0 = this.typeName.getEndToken()) && $0.is$Token());
 }
 // ********** Code for VariableDefinitions **************
 function VariableDefinitions(type, modifiers, definitions, endToken) {
   this.type = type;
   this.modifiers = modifiers;
   this.definitions = definitions;
   this.endToken = endToken;
   // Initializers done
 }
 $inherits(VariableDefinitions, Statement);
@@ skipping 141 matching lines @@
   }
   else {
     this.sb.add('var');
   }
   this.sb.add(' ');
   this.visit(node.definitions);
   if ($notnull_bool(node.endToken != null)) this.add((($0 = node.endToken.get$value()) && $0.is$SourceString()));
 }
 // ********** Code for top level **************
 function firstBeginToken(first, second) {
-  return $notnull_bool((first != null)) ? first.getBeginToken() : second.getBeginToken();
+  var $0;
+  return (($0 = $notnull_bool((first != null)) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
 }
 //  ********** Library elements **************
 // ********** Code for ElementKind **************
 function ElementKind(id) {
   this.id = id;
   // Initializers done
 }
 // ********** Code for Element **************
 function Element(name, kind, enclosingElement) {
   this.name = name;
@@ skipping 30 matching lines @@
   return types.dynamicType;
 }
 // ********** Code for FunctionElement **************
 function FunctionElement(name) {
   Element.call(this, name, const$239, null);
   // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
-  if ($notnull_bool(this.type != null)) return this.type;
+  if ($notnull_bool(this.type != null)) return (($0 = this.type) && $0.is$FunctionType());
   var node = (($0 = this.parseNode(compiler, compiler)) && $0.is$FunctionExpression());
   var returnType = getType(node.returnType, types);
   if ($notnull_bool(returnType == null)) compiler.cancel(('unknown type ' + returnType + ''));
   var parameterTypes = new LinkBuilderImplementation$Type();
   for (var link = node.parameters.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = link.get$tail()) {
     var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
-  return this.type;
+  return (($0 = this.type) && $0.is$FunctionType());
 }
 // ********** Code for ClassElement **************
 function ClassElement(name) {
   Element.call(this, name, const$237, null);
   // Initializers done
 }
 $inherits(ClassElement, Element);
 ClassElement.prototype.computeType = function(compiler, types) {
   compiler.unimplemented('ClassElement.computeType');
 }
 // ********** Code for top level **************
 function getType(annotation, types) {
+  var $0;
   if ($notnull_bool(annotation == null || annotation.typeName == null)) {
-    return types.dynamicType;
+    return (($0 = types.dynamicType) && $0.is$Type());
   }
-  return types.lookup(annotation.typeName.get$source());
+  return (($0 = types.lookup(annotation.typeName.get$source())) && $0.is$Type());
 }
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
 function SsaBuilderTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaBuilderTask, CompilerTask);
 SsaBuilderTask.prototype.get$name = function() {
   return 'SSA builder';
 }
 SsaBuilderTask.prototype.build = function(tree, elements) {
   var $this = this; // closure support
-  return this.measure((function () {
+  var $0;
+  return (($0 = this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var graph = $this.compileMethod(function_.parameters, function_.body, elements);
     $assert(graph.isValid(), "graph.isValid()", "builder.dart", 14, 14);
     if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
       var name = (($0 = function_.name) && $0.is$Identifier());
       HTracer.HTracer$singleton$factory().traceCompilation(name.get$source().toString());
       HTracer.HTracer$singleton$factory().traceGraph('builder', graph);
     }
     return graph;
   })
-  );
+  )) && $0.is$HGraph());
 }
 SsaBuilderTask.prototype.compileMethod = function(parameters, body, elements) {
   var builder = new SsaBuilder(this.compiler, elements);
   var graph = builder.build(parameters, body);
   return graph;
 }
 // ********** Code for SsaBuilder **************
 function SsaBuilder(compiler, elements) {
   this.compiler = compiler;
   this.elements = elements;
@@ skipping 21 matching lines @@
   var result = this.current;
   this.current.close(end);
   this.current = null;
   return result;
 }
 SsaBuilder.prototype.goto = function(from, to) {
   from.close(new HGoto());
   from.addSuccessor(to);
 }
 SsaBuilder.prototype.isAborted = function() {
-  return this.current == null;
+  return $assert_bool(this.current == null);
 }
 SsaBuilder.prototype.add = function(instruction) {
   this.current.add(instruction);
 }
 SsaBuilder.prototype.push = function(instruction) {
   this.add(instruction);
   this.stack.add(instruction);
 }
 SsaBuilder.prototype.pop = function() {
-  return this.stack.removeLast();
+  var $0;
+  return (($0 = this.stack.removeLast()) && $0.is$HInstruction());
 }
 SsaBuilder.prototype.visit = function(node) {
   if ($notnull_bool(node != null)) node.accept(this);
 }
 SsaBuilder.prototype.visitParameters = function(parameters) {
   var $0;
   var parameterIndex = 0;
   for (var link = parameters.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var container = (($0 = link.get$head()) && $0.is$VariableDefinitions());
@@ skipping 204 matching lines @@
 }
 SsaBuilder.prototype.updateDefinition = function(node) {
   var $0;
   if ($notnull_bool(node.receiver != null)) {
     this.compiler.unimplemented("SsaBuilder: property access");
   }
   var link = node.get$arguments();
   $assert(!$notnull_bool(link.isEmpty()) && link.get$tail().isEmpty(), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 362, 12);
   this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
-  return this.definitions.$setindex(this.elements.$index(node), value);
+  return (($0 = this.definitions.$setindex(this.elements.$index(node), value)) && $0.is$HInstruction());
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var definition = (($0 = link.get$head()) && $0.is$Node());
     if ($notnull_bool((definition instanceof Identifier))) {
       this.compiler.unimplemented("SsaBuilder.visitVariableDefinitions without initial value");
     }
     else {
       $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 377, 16);
       this.updateDefinition((definition && definition.is$SendSet()));
     }
   }
 }
 // ********** Code for SsaCodeGeneratorTask **************
 function SsaCodeGeneratorTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(tree, graph) {
   var $this = this; // closure support
-  return this.measure((function () {
+  return $assert_String(this.measure((function () {
     var $0;
     var function_ = (tree && tree.is$FunctionExpression());
     var name = (($0 = function_.name) && $0.is$Identifier());
     if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
       HTracer.HTracer$singleton$factory().traceGraph("codegen", graph);
     }
     var code = $this.generateMethod(name.get$source(), SsaCodeGeneratorTask.countParameters(function_), graph);
     return code;
   })
-  );
+  ));
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, parameterCount, graph) {
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.compiler, buffer);
   graph.assignInstructionIds();
   codegen.visitGraph(graph);
   var parameters = new StringBufferImpl("");
   for (var i = 0;
    $notnull_bool(i < parameterCount); i++) {
     if ($notnull_bool(i != 0)) parameters.add(', ');
@@ skipping 249 matching lines @@
     instruction = instruction.next;
   }
 }
 // ********** Code for HGraph **************
 function HGraph() {
   this.blocks = new ListFactory$HBasicBlock();
   // Initializers done
   this.entry = this.addNewBlock();
   this.exit = new HBasicBlock();
 }
+HGraph.prototype.is$HGraph = function(){return this;};
 HGraph.prototype.addBlock = function(block) {
   var id = this.blocks.length;
   block.id = id;
   this.blocks.add(block);
   $assert(this.blocks.$index(id) === block, "blocks[id] === block", "nodes.dart", 84, 12);
 }
 HGraph.prototype.addNewBlock = function() {
   var result = new HBasicBlock();
   this.addBlock(result);
   return result;
@@ skipping 217 matching lines @@
   $assert(this.isValid(), "isValid()", "nodes.dart", 290, 12);
 }
 HBasicBlock.rewriteInput = function(instruction, from, to) {
   var inputs = instruction.inputs;
   for (var i = 0;
    $notnull_bool(i < inputs.length); i++) {
     if ($notnull_bool(inputs.$index(i) === from)) inputs.$setindex(i, to);
   }
 }
 HBasicBlock.prototype.isExitBlock = function() {
-  return this.first === this.last && (this.first instanceof HExit);
+  return $assert_bool(this.first === this.last && (this.first instanceof HExit));
 }
 HBasicBlock.prototype.addDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 307, 12);
   $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 308, 12);
   $assert(this.dominatedBlocks.indexOf(block) < 0, "dominatedBlocks.indexOf(block) < 0", "nodes.dart", 309, 12);
   var index = this.dominatedBlocks.length;
   while ($notnull_bool(index > 0 && this.dominatedBlocks.$index(index - 1).id > block.id)) {
     index--;
   }
   if ($notnull_bool(index == this.dominatedBlocks.length)) {
@@ skipping 93 matching lines @@
   return this.getFlag(3/*HInstruction.FLAG_USE_GVN*/);
 }
 HInstruction.prototype.setUseGvn = function() {
   this.setFlag(3/*HInstruction.FLAG_USE_GVN*/);
 }
 HInstruction.prototype.get$usedBy = function() {
   if ($notnull_bool(this._usedBy == null)) return const$235/*const []*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
-  return this._usedBy != null;
+  return $assert_bool(this._usedBy != null);
 }
 HInstruction.prototype.equals = function(other) {
   $assert(this.useGvn() && other.useGvn(), "useGvn() && other.useGvn()", "nodes.dart", 443, 12);
   if ($notnull_bool(!$notnull_bool(this.typeEquals(other)))) return false;
   if ($notnull_bool(this.flags != other.flags)) return false;
   var inputsLength = this.inputs.length;
   var otherInputs = other.inputs;
   if ($notnull_bool(inputsLength != otherInputs.length)) return false;
   for (var i = 0;
    $notnull_bool(i < inputsLength); i++) {
@@ skipping 400 matching lines @@
   }
   return this.visitArithmetic(node);
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
-  return !$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty();
+  return $assert_bool(!$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty());
 }
 SsaDeadCodeEliminator.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaDeadCodeEliminator.prototype.visitBasicBlock = function(block) {
   var instruction = block.last;
   while ($notnull_bool(instruction != null)) {
     var previous = instruction.previous;
     if ($notnull_bool(SsaDeadCodeEliminator.isDeadCode(instruction))) block.remove(instruction);
     instruction = (previous && previous.is$HInstruction());
@@ skipping 48 matching lines @@
 SsaGlobalValueNumberer.prototype.getChangesFlagsForBlock = function(block) {
   var id = block.id;
   var cached = $assert_num(this.blockChangesFlags.$index(id));
   if ($notnull_bool(cached != null)) return cached;
   var changesFlags = 0;
   var instruction = block.first;
   while ($notnull_bool(instruction != null)) {
     changesFlags |= instruction.getChangesFlags();
     instruction = instruction.next;
   }
-  return this.blockChangesFlags.$setindex(id, changesFlags);
+  return $assert_num(this.blockChangesFlags.$setindex(id, changesFlags));
 }
 SsaGlobalValueNumberer.prototype.getChangesFlagsForDominatedBlock = function(dominator, dominated) {
   var $0;
   var changesFlags = 0;
   var predecessors = dominated.predecessors;
   for (var i = 0, length = predecessors.length;
    $notnull_bool(i < length); i++) {
     var block = (($0 = predecessors.$index(i)) && $0.is$HBasicBlock());
     var id = block.id;
     if ($notnull_bool(dominator.id < id && id < dominated.id && !$notnull_bool(this.visited.contains(id)))) {
@@ skipping 600 matching lines @@
 function ResolverTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(ResolverTask, CompilerTask);
 ResolverTask.prototype.get$name = function() {
   return 'Resolver';
 }
 ResolverTask.prototype.resolve = function(tree) {
   var $this = this; // closure support
-  return this.measure((function () {
+  var $0;
+  return (($0 = this.measure((function () {
     var visitor = new ResolverVisitor($this.compiler);
     visitor.visit(tree);
     return visitor.mapping;
   })
-  );
+  )) && $0.is$Map$Node$Element());
 }
 // ********** Code for ErrorMessages **************
 function ErrorMessages() {}
 ErrorMessages.cannotResolve = function(id) {
   return ("cannot resolve " + id + "");
 }
 ErrorMessages.cannotResolveType = function(id) {
   return ("cannot resolve type " + id + "");
 }
 ErrorMessages.duplicateDefinition = function(id) {
@@ skipping 117 matching lines @@
     this.warning(node, ErrorMessages.cannotResolveType(name));
   }
   return this.useElement(node, element);
 }
 ResolverVisitor.prototype.visitVariableDefinitions = function(node) {
   this.visit(node.type);
   var visitor = new VariableDefinitionsVisitor(node, this);
   visitor.visit(node.definitions);
 }
 ResolverVisitor.prototype.defineElement = function(node, element) {
+  var $0;
   this.compiler.ensure($assert_bool(element != null));
   this.mapping.$setindex(node, element);
-  return this.context.add(element);
+  return (($0 = this.context.add(element)) && $0.is$Element());
 }
 ResolverVisitor.prototype.useElement = function(node, element) {
   if ($notnull_bool(element == null)) return null;
   this.mapping.$setindex(node, element);
   return element;
 }
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
   this.definitions = definitions;
   this.resolver = resolver;
   // Initializers done
 }
 VariableDefinitionsVisitor.prototype.visitSendSet = function(node) {
   var $0;
   $assert(node.get$arguments().get$tail().isEmpty(), "node.arguments.tail.isEmpty()", "resolver.dart", 200, 12);
   if ($notnull_bool(node.receiver != null)) {
     this.resolver.compiler.unimplemented("receiver on a variable definition");
   }
   var selector = (($0 = node.selector) && $0.is$Identifier());
   this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
-  return this.visit(node.selector);
+  return (($0 = this.visit(node.selector)) && $0.is$SourceString());
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   return node.get$source();
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var name = (($0 = this.visit((($0 = link.get$head()) && $0.is$Node()))) && $0.is$SourceString());
     var element = new VariableElement((($0 = link.get$head()) && $0.is$Node()), this.definitions.type, name, this.resolver.context.enclosingElement);
@@ skipping 26 matching lines @@
 }
 Scope.enclosing$ctor.prototype = Scope.prototype;
 Scope.prototype.get$parent = function() { return this.parent; };
 Scope.prototype.lookup = function(name) {
   var $0;
   var element = (($0 = this.elements.$index(name)) && $0.is$Element());
   if ($notnull_bool(element != null)) return element;
   return this.parent.lookup(name);
 }
 Scope.prototype.add = function(element) {
-  if ($notnull_bool(this.elements.containsKey(element.name))) return this.elements.$index(element.name);
+  var $0;
+  if ($notnull_bool(this.elements.containsKey(element.name))) return (($0 = this.elements.$index(element.name)) && $0.is$Element());
   this.elements.$setindex(element.name, element);
   return element;
 }
 // ********** Code for TopScope **************
 function TopScope(universe) {
   this.universe = universe;
   Scope.top$ctor.call(this);
   // Initializers done
 }
 $inherits(TopScope, Scope);
@@ skipping 100 matching lines @@
   }
   else if ($notnull_bool($eq(const$10/*Types.DYNAMIC*/, s) || s.get$stringValue() === 'var')) {
     return this.dynamicType;
   }
   else if ($notnull_bool($eq(const$12/*Types.STRING*/, s))) {
     return this.stringType;
   }
   return null;
 }
 Types.prototype.isSubtype = function(r, s) {
-  return r === s || r === this.dynamicType || s === this.dynamicType;
+  return $assert_bool(r === s || r === this.dynamicType || s === this.dynamicType);
 }
 Types.prototype.isAssignable = function(r, s) {
-  return this.isSubtype(r, s) || this.isSubtype(s, r);
+  return $assert_bool(this.isSubtype(r, s) || this.isSubtype(s, r));
 }
 // ********** Code for CancelTypeCheckException **************
 function CancelTypeCheckException(node, reason) {
   this.node = node;
   this.reason = reason;
   // Initializers done
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(compiler, elements, types) {
   this.compiler = compiler;
@@ skipping 61 matching lines @@
   this.type(node.thenPart);
   if ($notnull_bool(node.get$hasElsePart())) this.type(node.elsePart);
   return this.types.voidType;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = this.elements.$index(node);
   if ($notnull_bool(target != null)) {
     var targetType = target.computeType(this.compiler, this.types);
     if ($notnull_bool(node.get$isPropertyAccess())) {
-      return targetType;
+      return (targetType && targetType.is$Type());
     }
     else if ($notnull_bool(node.get$isFunctionObjectInvocation())) {
       this.fail(node);
     }
     else {
       if ($notnull_bool(!(targetType instanceof FunctionType))) {
         if ($notnull_bool((target instanceof ForeignElement))) {
           return this.types.dynamicType;
         }
         this.fail(node, 'can only handle function types');
@@ skipping 105 matching lines @@
   return null;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
   this.generatedCode = $map([]);
   this.scope = new Element(const$2, null, null);
   // Initializers done
 }
 Universe.prototype.find = function(name) {
-  return this.elements.$index(name);
+  var $0;
+  return (($0 = this.elements.$index(name)) && $0.is$Element());
 }
 Universe.prototype.define = function(element) {
   $assert(this.elements.$index(element.name) == null, "elements[element.name] == null", "universe.dart", 20, 12);
   this.elements.$setindex(element.name, element);
 }
 Universe.prototype.addGeneratedCode = function(element, code) {
   this.generatedCode.$setindex(element, code);
 }
 // ********** Code for top level **************
 function unreachable() {
@@ skipping 141 matching lines @@
     w.writeln("/**\n * Generates a dynamic call stub for a function.\n * Our goal is to create a stub method like this on-the-fly:\n *   function($0, $1, capture) { this($0, $1, true, capture); }\n *\n * This stub then replaces the dynamic one on Function, with one that is\n * specialized for that particular function, taking into account its default\n * arguments.\n */\nFunction.prototype.$genStub = function(argsLength, names) {\n  // TODO(jmesserly): only emit $genStub if actually needed\n\n  // Fast path: if no named arguments and arg count matches\n  if (this.length == argsLength && !names) {\n    return this;\n  }\n\n  function $throwArgMismatch() {\n    // TODO(jmesserly): better error message\n    $throw(new ClosureArgumentMismatchException());\n  }\n\n  var paramsNamed = this.$optional ? (this.$optional.length / 2) : 0;\n  var paramsBare = this.length - paramsNamed;\n  var argsNamed = names ? names.length : 0;\n  var argsBare = argsLength - argsNamed;\n\n  // Check we got the right number of arguments\n  if (argsBare < paramsBare || argsLength > this.length ||\n      argsNamed > paramsNamed) {\n    return $throwArgMismatch;\n  }\n\n  // First, fill in all of the default values\n  var p = new Array(paramsBare);\n  if (paramsNamed) {\n    p = p.concat(this.$optional.slice(paramsNamed));\n  }\n  // Fill in positional args\n  var a = new Array(argsLength);\n  for (var i = 0; i < argsBare; i++) {\n    p[i] = a[i] = '$' + i;\n  }\n  // Then overwrite with supplied values for optional args\n  var lastParameterIndex;\n  var namesInOrder = true;\n  for (var i = 0; i < argsNamed; i++) {\n    var name = names[i];\n    a[i + argsBare] = name;\n    var j = this.$optional.indexOf(name, 0);\n    if (j < 0 || j >= paramsNamed) {\n      return $throwArgMismatch;\n    } else if (lastParameterIndex && lastParameterIndex > j) {\n      namesInOrder = false;\n    }\n    p[j + paramsBare] = name;\n    lastParameterIndex = j;\n  }\n\n  if (this.length == argsLength && namesInOrder) {\n    // Fast path #2: named arguments, but they're in order.\n    return this;\n  }\n\n  // Note: using Function instead of 'eval' to get a clean scope.\n  // TODO(jmesserly): evaluate the performance of these stubs.\n  var f = 'function(' + a.join(',') + '){return $f(' + p.join(',') + ');}';\n  return new Function('$f', 'return ' + f + '').call(null, this);\n}");
   }
   if ($notnull_bool(this.useStackTraceOf)) {
     w.writeln("function $stackTraceOf(e) {\n  // TODO(jmesserly): we shouldn't be relying on the e.stack property.\n  // Need to mangle it.\n  return e.stack ? e.stack : null;\n}");
   }
   if ($notnull_bool(this.useToDartException)) {
     w.writeln("// Translate a JavaScript exception to a Dart exception\n// TODO(jmesserly): cross browser support. This is Chrome specific.\nfunction $toDartException(e) {\n  var res = e;\n  if (e instanceof TypeError) {\n    switch(e.type) {\n      case 'property_not_function':\n      case 'called_non_callable':\n        if (e.arguments[0] == null) {\n          res = new NullPointerException();\n        } else {\n          res = new ObjectNotClosureException();\n        }\n        break;\n      case 'non_object_property_call':\n      case 'non_object_property_load':\n        res = new NullPointerException();\n        break;\n      case 'undefined_method':\n        if (e.arguments[0] == 'call' || e.arguments[0] == 'apply') {\n          res = new ObjectNotClosureException();\n        } else {\n          // TODO(jmesserly): can this ever happen?\n          res = new NoSuchMethodException('', e.arguments[0], []);\n        }\n        break;\n    }\n  } else if (e instanceof RangeError) {\n    if (e.message.indexOf('call stack') >= 0) {\n      res = new StackOverflowException();\n    }\n  }\n  // TODO(jmesserly): setting the stack property is not a long term solution.\n  // Also it causes the exception to print as if it were a TypeError or\n  // RangeError, instead of using the proper toString.\n  res.stack = e.stack;\n  return res;\n}");
   }
   if ($notnull_bool(this.useNotNullBool)) {
     this.useThrow = true;
-    w.writeln("function $notnull_bool(test) {\n  if (test == null || typeof(test) != 'boolean') {\n    $throw(new TypeError('must be \"true\" or \"false\"'));\n  }\n  return test === true;\n}");
+    w.writeln("function $notnull_bool(test) {\n  return typeof(test) == 'boolean' ? test : test.is$bool();\n}");
   }
   if ($notnull_bool(this.useAssert)) {
     this.useThrow = true;
     w.writeln("function $assert(test, text, url, line, column) {\n  if (typeof test == 'function') test = test();\n  if (!test) $throw(new AssertError(text, url, line, column));\n}");
   }
   if ($notnull_bool(this.useThrow)) {
     w.writeln("function $throw(e) {\n  // If e is not a value, we can use V8's captureStackTrace utility method.\n  // TODO(jmesserly): capture the stack trace on other JS engines.\n  if (e && (typeof e == 'object') && Error.captureStackTrace) {\n    // TODO(jmesserly): this will clobber the e.stack property\n    Error.captureStackTrace(e, $throw);\n  }\n  throw e;\n}");
   }
   if ($notnull_bool(this.useMap)) {
     w.writeln("function $map(items) {\n  var ret = new HashMapImplementation();\n  for (var i=0; i < items.length;) {\n    ret.$setindex(items[i++], items[i++]);\n  }\n  return ret;\n}");
@@ skipping 35 matching lines @@
   world.get$coreimpl().types.$index('StringImplementation').markUsed();
   world.get$coreimpl().types.$index('MatchImplementation').markUsed();
   this.genMethod((($0 = world.get$coreimpl().types.$index('MatchImplementation').getConstructor('')) && $0.is$Member()));
   this.writeTypes(world.get$coreimpl());
   this.writeTypes(world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
   this._writeGlobals();
   this.writer.writeln(('RunEntry(function () {' + mainCall.code + ';}, []);'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
+  var $0;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
   if ($notnull_bool(!$notnull_bool(this.globals.containsKey(fullname)))) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
-  return this.globals.$index(fullname);
+  return (($0 = this.globals.$index(fullname)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
+  var $0;
   var code = exp.canonicalCode;
   if ($notnull_bool(!$notnull_bool(this.globals.containsKey(code)))) {
     this.globals.$setindex(code, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
-  return this.globals.$index(code);
+  return (($0 = this.globals.$index(code)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if ($notnull_bool(lib.isWritten)) return;
   lib.isWritten = true;
   var $list = lib.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var import_ = $list.$index($i);
     this.writeTypes(import_.get$library());
   }
   for (var i = 0;
@@ skipping 253 matching lines @@
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var $0;
   this.corejs.useMap = true;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember('\$setindex');
   this.genMethod((($0 = m.get$members().$index(0)) && $0.is$Member()));
   var c = factType.getConstructor('');
   this.genMethod((c && c.is$Member()));
-  return factType;
+  return (factType && factType.is$lang_Type());
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
   // Initializers done
   if ($notnull_bool(this.get$isMethodScope())) {
     this._closedOver = new HashSetImplementation$String();
   }
   else {
     this.reentrant = $assert_bool(this.reentrant || this.parent.reentrant);
   }
 }
+BlockScope.prototype.is$BlockScope = function(){return this;};
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
-  return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
+  return $assert_bool(this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod));
 }
 BlockScope.prototype.get$methodScope = function() {
   var s = this;
   while ($notnull_bool(!$notnull_bool(s.get$isMethodScope()))) s = s.get$parent();
-  return s;
+  return (s && s.is$BlockScope());
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($notnull_bool($ne(ret, null))) return ret;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
     ret = s._vars.$index(name);
     if ($notnull_bool($ne(ret, null))) {
       if ($notnull_bool($ne(s.enclosingMethod, this.enclosingMethod))) {
         s.get$methodScope()._closedOver.add(ret.code);
@@ skipping 27 matching lines @@
     }
   }
   if ($notnull_bool(!$notnull_bool(isParameter))) {
     var index = 0;
     while ($notnull_bool(this._isDefinedInParent($assert_String(jsName)))) {
       jsName = ('' + name + '' + index++ + '');
     }
   }
   var ret = new Value(type, jsName, $notnull_bool(location != null) ? location.span : null, false, false, false);
   this._vars.$setindex(name, ret);
-  return ret;
+  return (ret && ret.is$Value());
 }
 BlockScope.prototype.declareParameter = function(p) {
   return this.create(p.name, p.type, p.definition, true);
 }
 BlockScope.prototype.declare = function(id) {
   var type = this.enclosingMethod.method.resolveType(id.type, false);
   return this.create(id.name.name, (type && type.is$lang_Type()), id, false);
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
@@ skipping 347 matching lines @@
       world.error('initialization cycle', node.span);
       break;
     }
     other = other.get$initDelegate();
   }
   world.gen.genMethod((m && m.is$Member()));
   var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
   if ($notnull_bool($ne(target.type, world.objectType))) {
     this.writer.writeln(('' + value.code + ';'));
   }
-  return target;
+  return (target && target.is$Value());
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var $0;
   var args = [];
   var seenLabel = false;
   for (var $i = 0;$i < arguments.length; $i++) {
     var arg = arguments.$index($i);
     if ($notnull_bool(arg.label != null)) {
       seenLabel = true;
     }
@@ skipping 25 matching lines @@
   this._scope = new BlockScope(this, this._scope, reentrant);
 }
 MethodGenerator.prototype._popBlock = function() {
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._makeLambdaMethod = function(name, func) {
   var meth = new MethodMember(name, this.method.declaringType, func);
   meth.isLambda = true;
   meth.resolve(this.method.declaringType);
   world.gen.genMethod((meth && meth.is$Member()), this);
-  return meth;
+  return (meth && meth.is$MethodMember());
 }
 MethodGenerator.prototype.visitBool = function(node) {
   return this.visitValue(node).convertToNonNullBool(this, node);
 }
 MethodGenerator.prototype.visitValue = function(node) {
   if ($notnull_bool(node == null)) return null;
   var value = node.visit(this);
   value.checkFirstClass(node.span);
   return value;
 }
@@ skipping 58 matching lines @@
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if ($notnull_bool(node.value == null)) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
     }
-    this.writer.writeln(('return ' + this.visitValue(node.value).code + ';'));
+    var value = this.visitTypedValue(node.value, this.method.get$returnType());
+    this.writer.writeln(('return ' + value.code + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitThrowStatement = function(node) {
   if ($notnull_bool(node.value != null)) {
     var value = this.visitValue(node.value);
     value.invoke$4(this, 'toString', node, Arguments.get$EMPTY());
     this.writer.writeln(('\$throw(' + value.code + ');'));
     world.gen.corejs.useThrow = true;
   }
@@ skipping 277 matching lines @@
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
   for (var i = 0;
    $notnull_bool(i < statementList.length); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit(this);
     if ($notnull_bool($ne(stmt, statementList.$index(statementList.length - 1)) && exits)) {
       world.warning('unreachable code', statementList.$index(i + 1).get$span());
     }
   }
-  return exits;
+  return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock('}');
   this._popBlock();
-  return exits;
+  return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitLabeledStatement = function(node) {
   this.writer.writeln(('' + node.name.name + ':'));
   node.body.visit(this);
   return false;
 }
 MethodGenerator.prototype.visitExpressionStatement = function(node) {
   if ($notnull_bool((node.body instanceof VarExpression) || (node.body instanceof ThisExpression))) {
     world.warning('variable used as statement', node.span);
   }
@@ skipping 372 matching lines @@
   for (var $i = 0;$i < $list.length; $i++) {
     var item = $list.$index($i);
     var arg = this.visitValue((item && item.is$lang_Expression()));
     argValues.add(arg);
     if ($notnull_bool(node.isConst)) {
       if ($notnull_bool(!$notnull_bool(arg.get$isConst()))) {
         world.error('const list can only contain const values', item.get$span());
         argsCode.add(arg.code);
       }
       else {
-        argsCode.add(arg.canonicalCode);
+        argsCode.add(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add(arg.code);
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed();
   var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var value = new Value(world.listType, code, node.span, false, true, false);
   if ($notnull_bool(node.isConst)) {
@@ skipping 16 matching lines @@
     var value = this.visitValue((valueItem && valueItem.is$lang_Expression()));
     argValues.add(key);
     argValues.add(value);
     if ($notnull_bool(node.isConst)) {
       if ($notnull_bool(!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst()))) {
         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);
+        argsCode.add(key.get$canonicalCode());
+        argsCode.add(value.get$canonicalCode());
       }
     }
     else {
       argsCode.add(key.code);
       argsCode.add(value.code);
     }
   }
   var argList = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var code = ('\$map(' + argList + ')');
   if ($notnull_bool(node.isConst)) {
@@ skipping 16 matching lines @@
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type, false);
   return value.instanceOf(this, (type && type.is$lang_Type()), node.span, node.isTrue, false);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var $0;
   var body = this.visitValue(node.body);
   if ($notnull_bool(body.get$isConst())) {
-    return EvaluatedValue.EvaluatedValue$factory((($0 = body.type) && $0.is$lang_Type()), body.get$actualValue(), ('(' + body.canonicalCode + ')'), node.span);
+    return EvaluatedValue.EvaluatedValue$factory((($0 = body.type) && $0.is$lang_Type()), body.get$actualValue(), ('(' + body.get$canonicalCode() + ')'), node.span);
   }
   return new Value(body.type, ('(' + body.code + ')'), node.span, false, true, false);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var name = node.name.name;
   var ret = this._scope.lookup(name);
@@ skipping 12 matching lines @@
 }
 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;
-  $assert($ne(type, null), "type != null", "gen.dart", 2075, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2078, 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 && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
         code = ('(' + code + ')');
@@ skipping 64 matching lines @@
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     if ($notnull_bool(this.getName(i) == name)) {
       return i;
     }
   }
   return -1;
 }
 Arguments.prototype.getValue = function(name) {
+  var $0;
   var i = this.getIndexOfName(name);
-  return $notnull_bool(i >= 0) ? this.values.$index(i) : null;
+  return (($0 = $notnull_bool(i >= 0) ? this.values.$index(i) : null) && $0.is$Value());
 }
 Arguments.prototype.get$bareCount = function() {
   if ($notnull_bool(this._bareCount == null)) {
     this._bareCount = this.get$length();
     if ($notnull_bool(this.nodes != null)) {
       for (var i = 0;
        $notnull_bool(i < this.nodes.length); i++) {
         if ($notnull_bool(this.nodes.$index(i).label != null)) {
           this._bareCount = i;
           break;
@@ skipping 16 matching lines @@
   while ($notnull_bool(argsCode.length > 0 && $eq(argsCode.last(), 'null'))) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
   var names = [];
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     names.add(this.getName(i));
   }
-  return names;
+  return (names && names.is$List$String());
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = 0;
    $notnull_bool(i < this.get$bareCount()); i++) {
     result.add(new Value(world.varType, ('\$' + i + ''), null, false, false, false));
   }
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     var name = this.getName(i);
@@ skipping 50 matching lines @@
 }
 Library.prototype.addImport = function(fullname, prefix) {
   var newLib = world.getOrAddLibrary(fullname);
   this.imports.add(new LibraryImport(newLib, prefix));
   return newLib;
 }
 Library.prototype.addNative = function(fullname) {
   this.natives.add(world.reader.readFile(fullname));
 }
 Library.prototype._findMembers = function(name) {
+  var $0;
   if ($notnull_bool(name.startsWith('_'))) {
-    return this._privateMembers.$index(name);
+    return (($0 = this._privateMembers.$index(name)) && $0.is$MemberSet());
   }
   else {
-    return world._members.$index(name);
+    return (($0 = world._members.$index(name)) && $0.is$MemberSet());
   }
 }
 Library.prototype._addMember = function(member) {
   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;
@@ skipping 21 matching lines @@
 }
 Library.prototype.getOrAddFunctionType = function(name, func, inType) {
   var def = new FunctionTypeDefinition(func, null, func.span);
   var type = new DefinedType(name, this, def, false);
   type.addMethod('\$call', func);
   type.members.$index('\$call').resolve(inType);
   type.interfaces = [world.functionType];
   return type;
 }
 Library.prototype.addType = function(name, definition, isClass) {
+  var $0;
   if ($notnull_bool(this.types.containsKey(name))) {
     var existingType = this.types.$index(name);
     if ($notnull_bool(this.get$isCore() && existingType.get$definition() == null)) {
       existingType.setDefinition((definition && definition.is$Definition()));
     }
     else {
       world.warning(('duplicate definition of ' + name + ''), definition.span);
     }
   }
   else {
     this.types.$setindex(name, new DefinedType(name, this, (definition && definition.is$Definition()), isClass));
   }
-  return this.types.$index(name);
+  return (($0 = this.types.$index(name)) && $0.is$DefinedType());
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if ($notnull_bool(result == null)) return null;
   if ($notnull_bool(type.names != null)) {
     if ($notnull_bool(type.names.length > 1)) {
       return null;
     }
     if ($notnull_bool(!$notnull_bool(result.get$isTop()))) {
       return null;
@@ skipping 16 matching lines @@
     }
     if ($notnull_bool($ne(newRet, null))) {
       if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
         world.error(('conflicting types for "' + name + '"'), ret.get$span(), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
   }
-  return ret;
+  return (ret && ret.is$lang_Type());
 }
 Library.prototype.lookup = function(name, span) {
   var retType = this.findTypeByName(name);
   var ret = null;
   if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name);
   if ($notnull_bool($ne(newRet, null))) {
     if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
@@ skipping 11 matching lines @@
       if ($notnull_bool($ne(newRet, null))) {
         if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
           world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
         }
         else {
           ret = newRet;
         }
       }
     }
   }
-  return ret;
+  return (ret && ret.is$Member());
 }
 Library.prototype.resolve = function() {
   var $0;
   if ($notnull_bool(this.name == null)) {
     this.name = this.baseSource.filename;
     var index = this.name.lastIndexOf('/', this.name.length);
     if ($notnull_bool(index >= 0)) {
       this.name = this.name.substring(index + 1);
     }
     index = this.name.indexOf('.', 0);
@@ skipping 253 matching lines @@
     context = new MethodGenerator(method, null);
   }
   this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   ret.isInitializer = this.isInitializer;
-  return ret;
+  return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
-  return this.definition != null && this.definition.value != null;
+  return $assert_bool(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;};
@@ skipping 34 matching lines @@
 Member.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 Member.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 Member.prototype.get$isNative = function() {
   return false;
 }
 Member.prototype.get$constructorName = function() {
-  return world.internalError('can not be a constructor', this.get$span());
+  world.internalError('can not be a constructor', this.get$span());
 }
 Member.prototype.provideFieldSyntax = function() {
   return world.internalError('can not be field', this.get$span());
 }
 Member.prototype.providePropertySyntax = function() {
   return world.internalError('can not be property', this.get$span());
 }
 Member.prototype.get$initDelegate = function() {
-  return world.internalError('cannot have initializers', this.get$span());
+  world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.set$initDelegate = function(ctor) {
-  return world.internalError('cannot have initializers', this.get$span());
+  world.internalError('cannot have initializers', this.get$span());
 }
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
-  return this.get$canGet() && new Value(this.get$returnType(), null, null, false, true, false).canInvoke(context, '\$call', args);
+  return $assert_bool(this.get$canGet() && new Value(this.get$returnType(), null, 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 ($notnull_bool(this.get$isStatic())) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 175, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 178, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if ($notnull_bool(this.name == '')) {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
 Member.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
   if ($notnull_bool(this.get$isStatic() && type.get$hasTypeParams())) {
     world.error('using type parameter in static context', node.span);
   }
-  return type;
+  return (type && type.is$lang_Type());
 }
 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 = 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()));
 }
 ;
 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);
 }
 ;
 // ********** Code for TypeMember **************
 function TypeMember(type) {
   this.type = type;
   Member.call(this, type.name, type.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
+TypeMember.prototype.is$TypeMember = function(){return this;};
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
   return world.varType;
 }
 TypeMember.prototype.canInvoke = function(context, args) {
@@ skipping 60 matching lines @@
 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;
+  this._providePropertySyntax = true;
 }
 FieldMember.prototype.get$span = function() {
-  return $notnull_bool(this.definition == null) ? null : this.definition.span;
+  var $0;
+  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
 }
 FieldMember.prototype.get$returnType = function() {
   return this.type;
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !$notnull_bool(this.isFinal);
 }
@@ skipping 55 matching lines @@
       }
     }
     if ($notnull_bool(this.isStatic)) {
       this._computedValue = world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
     }
     this._computing = false;
   }
   return this._computedValue;
 }
 FieldMember.prototype._get = function(context, node, target, isDynamic) {
+  var $0;
   if ($notnull_bool(!$notnull_bool(isDynamic))) {
     this.declaringType.markUsed();
   }
   if ($notnull_bool(this.isStatic)) {
     var cv = this.computeValue();
     if ($notnull_bool(this.isFinal)) {
-      return cv;
+      return (cv && cv.is$Value());
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), node.span, false, true, false);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), node.span, false, true, false);
     }
   }
   else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
     var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.get$dynamic().exp : target;
     if ($notnull_bool((constTarget instanceof ConstObjectValue))) {
-      return constTarget.fields.$index(this.name);
+      return (($0 = constTarget.fields.$index(this.name)) && $0.is$Value());
     }
     else if ($notnull_bool($eq(constTarget.type, world.stringType) && this.name == 'length')) {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), node.span, false, true, false);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, false, true, false);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
   return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), node.span, false, true, false);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
   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 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   Member.call(this, name, declaringType);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
 PropertyMember.prototype.get$span = function() {
-  return $notnull_bool(this.getter != null) ? this.getter.get$span() : null;
+  var $0;
+  return (($0 = $notnull_bool(this.getter != null) ? this.getter.get$span() : null) && $0.is$SourceSpan());
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
 PropertyMember.prototype.get$canSet = function() {
   return this.setter != null;
 }
 PropertyMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 PropertyMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 PropertyMember.prototype.provideFieldSyntax = function() {
-  return this._provideFieldSyntax = true;
+  this._provideFieldSyntax = true;
 }
 PropertyMember.prototype.providePropertySyntax = function() {
 
 }
 PropertyMember.prototype.get$isStatic = function() {
   return $notnull_bool(this.getter == null) ? this.setter.isStatic : this.getter.isStatic;
 }
 PropertyMember.prototype.get$isProperty = function() {
   return true;
 }
@@ skipping 132 matching lines @@
 ConcreteMember.prototype.providePropertySyntax = function() {
   return this.baseMember.providePropertySyntax();
 }
 ConcreteMember.prototype.get$isConstructor = function() {
   return this.name == this.declaringType.name;
 }
 ConcreteMember.prototype.get$constructorName = function() {
   return this.baseMember.get$constructorName();
 }
 ConcreteMember.prototype.get$definition = function() {
-  return this.baseMember.get$definition();
+  var $0;
+  return (($0 = this.baseMember.get$definition()) && $0.is$Definition());
 }
 ConcreteMember.prototype.get$initDelegate = function() {
-  return this.baseMember.get$initDelegate();
+  var $0;
+  return (($0 = this.baseMember.get$initDelegate()) && $0.is$Definition());
 }
 ConcreteMember.prototype.set$initDelegate = function(ctor) {
   this.baseMember.set$initDelegate(ctor);
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var type = this.baseMember.resolveType(node, isRequired);
   return type.resolveTypeParams(this.declaringType);
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
@@ skipping 68 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 $notnull_bool(this.definition == null) ? null : this.definition.span;
+  var $0;
+  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
 }
 MethodMember.prototype.get$constructorName = function() {
   var $0;
   var returnType = (($0 = this.definition.returnType) && $0.is$NameTypeReference());
   if ($notnull_bool(returnType == null)) return '';
   if ($notnull_bool(returnType.names != null)) {
-    return returnType.names.$index(0).get$name();
+    return $assert_String(returnType.names.$index(0).get$name());
   }
   else if ($notnull_bool(returnType.name != null)) {
     return returnType.name.name;
   }
   world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
   if ($notnull_bool(this._functionType == null)) {
     this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
     if ($notnull_bool(this.parameters == null)) {
@@ skipping 39 matching lines @@
   }
   return -1;
 }
 MethodMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 MethodMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 MethodMember.prototype.provideFieldSyntax = function() {
-  return this._provideFieldSyntax = true;
+  this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
-  return this._providePropertySyntax = true;
+  this._providePropertySyntax = true;
 }
 MethodMember.prototype._set = function(context, Node, 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 ($notnull_bool(this.isStatic)) {
     var type = $notnull_bool(this.declaringType.get$isTop()) ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), node.span, false, true, false);
@@ skipping 77 matching lines @@
   var bareCount = args.get$bareCount();
   for (var i = 0;
    $notnull_bool(i < bareCount); i++) {
     var arg = args.values.$index(i);
     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, $assert_String(msg));
     }
     arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
     if ($notnull_bool(this.isConst && arg.get$isConst())) {
-      argsCode.add(arg.canonicalCode);
+      argsCode.add(arg.get$canonicalCode());
     }
     else {
       argsCode.add(arg.code);
     }
   }
   if ($notnull_bool(bareCount < this.parameters.length)) {
     this.genParameterValues();
     var namedArgsUsed = 0;
     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(arg == null)) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
         arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
         namedArgsUsed++;
       }
       if ($notnull_bool(arg == null || !$notnull_bool(this.parameters.$index(i).get$isOptional()))) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
-        argsCode.add($notnull_bool(this.isConst && arg.get$isConst()) ? arg.canonicalCode : arg.code);
+        argsCode.add($notnull_bool(this.isConst && arg.get$isConst()) ? arg.get$canonicalCode() : arg.code);
       }
     }
     if ($notnull_bool(namedArgsUsed < args.get$nameCount())) {
       var seen = new HashSetImplementation$String();
       for (var i = bareCount;
        $notnull_bool(i < args.get$length()); i++) {
         var name = args.getName(i);
         if ($notnull_bool(seen.contains(name))) {
           return this._argError(context, node, target, args, ('duplicate argument "' + name + '"'));
         }
@@ skipping 103 matching lines @@
       }
       this.generator._scope._vars.$setindex(name, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
       if ($notnull_bool((init instanceof CallExpression))) {
         var delegateArgs = this.generator._makeArgs((($0 = init.get$arguments()) && $0.is$List$ArgumentNode()));
         var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
         if ($notnull_bool((init.target instanceof ThisExpression))) {
-          return value;
+          return (value && value.is$Value());
         }
         else {
           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));
           }
@@ skipping 326 matching lines @@
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
     return (m instanceof MethodMember);
   })
   );
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
-  return this.members.length == 1 && this.members.$index(0).get$isStatic();
+  return $assert_bool(this.members.length == 1 && this.members.$index(0).get$isStatic());
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if ($notnull_bool(!$notnull_bool(target.type.get$isVar()))) {
     world.warning(('could not find applicable ' + action + ' for "' + this.name + '"'), node.span);
@@ skipping 153 matching lines @@
       return m.canInvoke(context, args);
     })
     );
     var returnType = reduce(map((targets && targets.is$Iterable()), (function (t) {
       return t.get$returnType();
     })
     ), lang_Type.union);
     stub = new VarMethodSet($assert_String(stubName), targets, args, returnType);
     world.objectType.varStubs.$setindex(stubName, stub);
   }
-  return stub;
+  return (stub && stub.is$VarMember());
 }
 MemberSet.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MemberSet.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 MemberSet.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);
 }
 ;
 // ********** Code for FactoryMap **************
 function FactoryMap() {
   this.factories = $map([]);
   // Initializers done
 }
 FactoryMap.prototype.getFactoriesFor = function(typeName) {
   var ret = this.factories.$index(typeName);
   if ($notnull_bool(ret == null)) {
     ret = $map([]);
     this.factories.$setindex(typeName, ret);
   }
-  return ret;
+  return (ret && ret.is$Map$String$Member());
 }
 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);
+  var $0;
+  return (($0 = this.getFactoriesFor(typeName).$index(name)) && $0.is$Member());
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
       f(member);
     })
     );
   })
   );
 }
@@ skipping 11 matching lines @@
 lang_Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($notnull_bool($ne(kindText, actualText))) {
     if ($notnull_bool(actualText.length > 10)) {
       actualText = actualText.substring(0, 8) + '...';
     }
     return ('' + kindText + '(' + actualText + ')');
   }
   else {
-    return kindText;
+    return $assert_String(kindText);
   }
 }
 lang_Token.prototype.get$span = function() {
   return new SourceSpan(this.source, this.start, this.end);
 }
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
@@ skipping 43 matching lines @@
     buf.add(textLine);
     var i = 0;
     for (; $notnull_bool(i < $assert_num(column)); i++) {
       buf.add(' ');
     }
     var toColumn = Math.min($assert_num(column + (end - start)), textLine.length);
     for (; $notnull_bool(i < toColumn); i++) {
       buf.add('^');
     }
   }
-  return buf.toString();
+  return $assert_String(buf.toString());
 }
 SourceFile.prototype.compareTo = function(other) {
   if ($notnull_bool(this.orderInLibrary != null && other.orderInLibrary != null)) {
     return this.orderInLibrary - other.orderInLibrary;
   }
   else {
     return this.filename.compareTo(other.filename);
   }
 }
 // ********** Code for SourceSpan **************
@@ skipping 23 matching lines @@
   return this.file.compareTo(other.file);
 }
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = -1;
   // Initializers done
 }
+InterpStack.prototype.is$InterpStack = function(){return this;};
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
   if ($notnull_bool(stack != null)) newStack.previous = stack;
-  return newStack;
+  return (newStack && newStack.is$InterpStack());
 }
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._lang_index = _index;
   // Initializers done
   this._text = this._source.get$text();
 }
 $inherits(TokenizerBase, TokenizerHelpers);
@@ skipping 251 matching lines @@
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
-      return this.maybeEatHexDigit() && this.maybeEatHexDigit();
+      return $assert_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit());
 
     case 117:
 
       if ($notnull_bool(this._maybeEatChar(123))) {
         var start = this._lang_index;
         this.eatHexDigits();
         var chars = this._lang_index - start;
         if ($notnull_bool(chars > 0 && chars <= 6 && this._maybeEatChar(125))) {
           hex = this._text.substring(start, start + chars);
           break;
@@ skipping 11 matching lines @@
           return false;
         }
       }
 
     default:
 
       return true;
 
   }
   var n = lang_Parser.parseHex(hex);
-  return n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF;
+  return $assert_bool(n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF);
 }
 TokenizerBase.prototype.finishDot = function() {
   if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
     this.eatDigits();
     return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
@@ skipping 538 matching lines @@
 
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 // ********** Code for TokenizerHelpers **************
 function TokenizerHelpers() {}
 TokenizerHelpers.isIdentifierStart = function(c) {
-  return ((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95);
+  return $assert_bool(((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95));
 }
 TokenizerHelpers.isDigit = function(c) {
-  return (c >= 48 && c <= 57);
+  return $assert_bool((c >= 48 && c <= 57));
 }
 TokenizerHelpers.isHexDigit = function(c) {
-  return (TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70));
+  return $assert_bool((TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70)));
 }
 TokenizerHelpers.isWhitespace = function(c) {
-  return (c == 32 || c == 9 || c == 10 || c == 13);
+  return $assert_bool((c == 32 || c == 9 || c == 10 || c == 13));
 }
 TokenizerHelpers.isIdentifierPart = function(c) {
-  return (TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c));
+  return $assert_bool((TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c)));
 }
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
     case 1/*TokenKind.END_OF_FILE*/:
 
       return "end of file";
 
     case 2/*TokenKind.LPAREN*/:
@@ skipping 448 matching lines @@
 
       return "keyword 'while'";
 
     default:
 
       return "TokenKind(" + kind.toString() + ")";
 
   }
 }
 TokenKind.isIdentifier = function(kind) {
-  return kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 88/*TokenKind.BREAK*/;
+  return $assert_bool(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 415 matching lines @@
 }
 lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add(this.directive());
   }
   while ($notnull_bool(!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/)))) {
     ret.add(this.topLevelDefinition());
   }
-  return ret;
+  return (ret && ret.is$List$Definition());
 }
 lang_Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
   return new DirectiveDefinition(name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.topLevelDefinition = function() {
@@ skipping 194 matching lines @@
     name = new lang_Identifier('', names.$index(0).get$span());
   }
   if ($notnull_bool(names.length > 1)) {
     this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 lang_Parser.prototype.statement = function() {
+  var $0;
   switch (this._peek()) {
     case 88/*TokenKind.BREAK*/:
 
-      return this.breakStatement();
+      return (($0 = this.breakStatement()) && $0.is$lang_Statement());
 
     case 92/*TokenKind.CONTINUE*/:
 
-      return this.continueStatement();
+      return (($0 = this.continueStatement()) && $0.is$lang_Statement());
 
     case 105/*TokenKind.RETURN*/:
 
-      return this.returnStatement();
+      return (($0 = this.returnStatement()) && $0.is$lang_Statement());
 
     case 109/*TokenKind.THROW*/:
 
-      return this.throwStatement();
+      return (($0 = this.throwStatement()) && $0.is$lang_Statement());
 
     case 72/*TokenKind.ASSERT*/:
 
-      return this.assertStatement();
+      return (($0 = this.assertStatement()) && $0.is$lang_Statement());
 
     case 114/*TokenKind.WHILE*/:
 
       return this.whileStatement();
 
     case 94/*TokenKind.DO*/:
 
       return this.doStatement();
 
     case 99/*TokenKind.FOR*/:
 
-      return this.forStatement();
+      return (($0 = this.forStatement()) && $0.is$lang_Statement());
 
     case 100/*TokenKind.IF*/:
 
       return this.ifStatement();
 
     case 107/*TokenKind.SWITCH*/:
 
-      return this.switchStatement();
+      return (($0 = this.switchStatement()) && $0.is$lang_Statement());
 
     case 111/*TokenKind.TRY*/:
 
-      return this.tryStatement();
+      return (($0 = this.tryStatement()) && $0.is$lang_Statement());
 
     case 6/*TokenKind.LBRACE*/:
 
       return this.block();
 
     case 10/*TokenKind.SEMICOLON*/:
 
       return this.emptyStatement();
 
     case 97/*TokenKind.FINAL*/:
 
-      return this.declaration(false);
+      return (($0 = this.declaration(false)) && $0.is$lang_Statement());
 
     case 112/*TokenKind.VAR*/:
 
-      return this.declaration(false);
+      return (($0 = this.declaration(false)) && $0.is$lang_Statement());
 
     default:
 
-      return this.finishExpressionAsStatement(this.expression());
+      return (($0 = this.finishExpressionAsStatement(this.expression())) && $0.is$lang_Statement());
 
   }
 }
 lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
   var $0;
   var start = expr.get$span().start;
   if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
@@ skipping 28 matching lines @@
   }
   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;
+  return (ret && ret.is$lang_Expression());
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
   while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
@@ skipping 708 matching lines @@
   }
 }
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    $notnull_bool(i < hex.length); i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
     $assert($ne(digit, -1), "digit != -1", "parser.dart", 1257, 14);
     result = (result << 4) + $assert_num(digit);
   }
-  return result;
+  return $assert_num(result);
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
   var type = this.type(0);
   var name = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   var args = this.arguments();
   return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
 }
@@ skipping 368 matching lines @@
     return null;
   }
 }
 // ********** Code for IncompleteSourceException **************
 function IncompleteSourceException(token) {
   this.token = token;
   // Initializers done
 }
 IncompleteSourceException.prototype.toString = function() {
   if ($notnull_bool(this.token.get$span() == null)) return ('Unexpected ' + this.token + '');
-  return this.token.get$span().toMessageString(('Unexpected ' + this.token + ''));
+  return $assert_String(this.token.get$span().toMessageString(('Unexpected ' + this.token + '')));
 }
 // ********** Code for lang_Node **************
 function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
 lang_Node.prototype.is$lang_Node = function(){return this;};
 lang_Node.prototype.get$span = function() { return this.span; };
 lang_Node.prototype.set$span = function(value) { return this.span = value; };
 // ********** Code for Definition **************
@@ skipping 685 matching lines @@
   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() {
+  var $0;
   if ($notnull_bool(this._typeMember == null)) {
     this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
-  return this._typeMember;
+  return (($0 = this._typeMember) && $0.is$TypeMember());
 }
 lang_Type.prototype.getMember = function(name) {
   return null;
 }
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
 lang_Type.prototype.get$isTop = function() {
   return false;
 }
@@ skipping 12 matching lines @@
 lang_Type.prototype.get$isList = function() {
   return false;
 }
 lang_Type.prototype.get$isNum = function() {
   return false;
 }
 lang_Type.prototype.get$isVoid = function() {
   return false;
 }
 lang_Type.prototype.get$isVarOrFunction = function() {
-  return this.get$isVar() || this.get$isFunction();
+  return $assert_bool(this.get$isVar() || this.get$isFunction());
 }
 lang_Type.prototype.getCallMethod = function() {
   return null;
 }
 lang_Type.prototype.get$isClosed = function() {
-  return this.get$isString() || this.get$isBool() || this.get$isNum() || this.get$isFunction() || this.get$isVar();
+  return $assert_bool(this.get$isString() || this.get$isBool() || this.get$isNum() || this.get$isFunction() || this.get$isVar());
 }
 lang_Type.prototype.get$isUsed = function() {
   return false;
 }
 lang_Type.prototype.get$isGeneric = function() {
   return false;
 }
 lang_Type.prototype.get$isNativeType = function() {
   return false;
 }
@@ skipping 18 matching lines @@
 lang_Type.prototype.get$definition = function() {
   return null;
 }
 lang_Type.prototype.get$factories = function() {
   return null;
 }
 lang_Type.prototype.get$typeArgsInOrder = function() {
   return null;
 }
 lang_Type.prototype.get$genericType = function() {
-  return this;
+  return (this && this.is$DefinedType());
 }
 lang_Type.prototype.get$interfaces = function() {
   return null;
 }
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
@@ skipping 23 matching lines @@
   }
   return false;
 }
 lang_Type.union = function(x, y) {
   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);
+  return $assert_bool(this.isSubtypeOf(other) || other.isSubtypeOf(this));
 }
 lang_Type.prototype._isDirectSupertypeOf = function(other) {
   var $this = this; // closure support
   if ($notnull_bool(other.get$isClass())) {
-    return $eq(other.get$parent(), this) || this.get$isObject() && other.get$parent() == null;
+    return $assert_bool($eq(other.get$parent(), this) || this.get$isObject() && other.get$parent() == null);
   }
   else {
     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);
       })
       );
@@ skipping 60 matching lines @@
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.get$constructors = function() {
-  return world.internalError('no constructors on type parameters yet');
+  world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.getCallMethod = function() {
   return this.extendsType.getCallMethod();
 }
 ParameterType.prototype.genMethod = function(method) {
   this.extendsType.genMethod(method);
 }
 ParameterType.prototype.isSubtypeOf = function(child) {
   return true;
 }
 ParameterType.prototype.resolveMember = function(memberName) {
   return this.extendsType.resolveMember(memberName);
 }
 ParameterType.prototype.getConstructor = function(constructorName) {
   world.internalError('no constructors on type parameters yet');
 }
 ParameterType.prototype.getOrMakeConcreteType = function(typeArgs) {
   world.internalError('no concrete types of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
-  return inType.typeArguments.$index(this.name);
+  var $0;
+  return (($0 = inType.typeArguments.$index(this.name)) && $0.is$lang_Type());
 }
 ParameterType.prototype.addDirectSubtype = function(type) {
   world.internalError('no subtypes of type parameters yet', this.get$span());
 }
 ParameterType.prototype.resolve = function(inType) {
   if ($notnull_bool(this.typeParameter.extendsType != null)) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
@@ skipping 75 matching lines @@
   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 ($notnull_bool($ne(myMember, null))) {
       result.$setindex(memberName, myMember);
     }
   }
-  return result;
+  return (result && result.is$Map$String$Member());
 }
 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);
 }
@@ skipping 14 matching lines @@
     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 ($notnull_bool($ne(ret, null))) return ret;
+  if ($notnull_bool($ne(ret, null))) return (ret && ret.is$Member());
   var genericMember = this.genericType.getMember(memberName);
   if ($notnull_bool(genericMember == null)) return null;
   ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
   this.members.$setindex(memberName, ret);
-  return ret;
+  return (ret && ret.is$Member());
 }
 ConcreteType.prototype.resolveMember = function(memberName) {
   var $0;
   var mem = this.getMember(memberName);
   if ($notnull_bool(mem == null)) return null;
   var ret = new MemberSet((mem && mem.is$Member()));
-  if ($notnull_bool(mem.get$isStatic())) return ret;
+  if ($notnull_bool(mem.get$isStatic())) return (ret && ret.is$MemberSet());
   var $list = this.genericType.get$subtypes();
   for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext(); ) {
     var t = $i.next();
     var m = t.get$members().$index(memberName);
     if ($notnull_bool($ne(m, null))) ret.add(m);
   }
-  return ret;
+  return (ret && ret.is$MemberSet());
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
-  return ret;
+  return (ret && ret.is$lang_Type());
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 // ********** Code for DefinedType **************
 function DefinedType(name, library, definition, 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, name);
   // Initializers done
   this.setDefinition(definition);
 }
 $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(p) {
-  return this._parent = p;
+  this._parent = p;
 }
 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$constructors = function() { return this.constructors; };
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 563, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 564, 12);
   this.definition = def;
   if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null)) {
     this.isNativeType = true;
   }
   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);
@@ skipping 12 matching lines @@
 DefinedType.prototype.get$isVar = function() {
   return $eq(this, world.varType);
 }
 DefinedType.prototype.get$isVoid = function() {
   return $eq(this, world.voidType);
 }
 DefinedType.prototype.get$isTop = function() {
   return this.name == null;
 }
 DefinedType.prototype.get$isObject = function() {
-  return this.library.get$isCore() && this.name == 'Object';
+  return $assert_bool(this.library.get$isCore() && this.name == 'Object');
 }
 DefinedType.prototype.get$isString = function() {
-  return this.library.get$isCore() && this.name == 'String' || this.library.get$isCoreImpl() && this.name == 'StringImplementation';
+  return $assert_bool(this.library.get$isCore() && this.name == 'String' || this.library.get$isCoreImpl() && this.name == 'StringImplementation');
 }
 DefinedType.prototype.get$isBool = function() {
-  return this.library.get$isCore() && this.name == 'bool';
+  return $assert_bool(this.library.get$isCore() && this.name == 'bool');
 }
 DefinedType.prototype.get$isFunction = function() {
-  return this.library.get$isCore() && this.name == 'Function';
+  return $assert_bool(this.library.get$isCore() && this.name == 'Function');
 }
 DefinedType.prototype.get$isList = function() {
-  return this.library.get$isCore() && this.name == 'List';
+  return $assert_bool(this.library.get$isCore() && this.name == 'List');
 }
 DefinedType.prototype.get$isGeneric = function() {
   return this.typeParameters != null;
 }
 DefinedType.prototype.get$span = function() {
-  return $notnull_bool(this.definition == null) ? null : this.definition.span;
+  var $0;
+  return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
 }
 DefinedType.prototype.get$typeofName = function() {
   if ($notnull_bool(!$notnull_bool(this.library.get$isCore()))) return null;
   if ($notnull_bool(this.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');
+  return $assert_bool(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');
+  var $0;
+  return (($0 = this.members.$index('\$call')) && $0.is$MethodMember());
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if ($notnull_bool(this.isUsed)) return;
   this.isUsed = true;
   if ($notnull_bool(this._lazyGenMethods != null)) {
     var $list = orderValuesByKeys(this._lazyGenMethods);
     for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 18 matching lines @@
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool((this.library.get$isCore() || this.library.get$isCoreImpl())))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
     interfaces.add(resolvedInterface);
   }
-  return interfaces;
+  return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 679, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 680, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   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);
@@ skipping 255 matching lines @@
 }
 DefinedType.prototype.getMemberInParents = function(memberName) {
   if ($notnull_bool(this.isClass)) {
     if ($notnull_bool(this.get$parent() != null)) {
       return this.get$parent().getMember(memberName);
     }
     else if ($notnull_bool(this.get$isObject())) {
       if ($notnull_bool(memberName == '\$ne')) {
         var ret = this._createNotEqualMember();
         this.members.$setindex(memberName, ret);
-        return ret;
+        return (ret && ret.is$Member());
       }
       return null;
     }
   }
   else {
     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 ($notnull_bool($ne(ret, null))) {
-          return ret;
+          return (ret && ret.is$Member());
         }
       }
       return null;
     }
     else {
       return world.objectType.getMember(memberName);
     }
   }
 }
 DefinedType.prototype.resolveMember = function(memberName) {
@@ skipping 119 matching lines @@
   }
   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", 1161, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1162, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    $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 && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
-  return ret;
+  return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1181, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1182, 12);
   var name = _getCallStubName('call', args);
   if ($notnull_bool(this.varStubs == null)) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
-  return stub;
+  return (stub && stub.is$VarFunctionStub());
 }
 // ********** 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() {
@@ skipping 19 matching lines @@
 }
 $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.is$Iterator$T = function(){return this;};
 FixedIterator.prototype.get$value = function() { return this.value; };
 FixedIterator.prototype.hasNext = function() {
   return this._index < this.length;
 }
 FixedIterator.prototype.next = function() {
   this._index++;
   return this.value;
 }
 // ********** Code for FixedIterator$E **************
 function FixedIterator$E(value, length) {
   this._index = 0
   this.value = value;
   this.length = length;
   // Initializers done
 }
 $inherits(FixedIterator$E, FixedIterator);
+FixedIterator$E.prototype.is$Iterator$T = function(){return this;};
 // ********** Code for Value **************
 function Value(type, code, span, isSuper, needsTemp, isType) {
   this.type = type;
   this.code = code;
   this.span = span;
   this.isSuper = isSuper;
   this.needsTemp = needsTemp;
   this.isType = isType;
   // Initializers done
   if ($notnull_bool(this.type == null)) this.type = world.varType;
 }
 Value.prototype.is$Value = function(){return this;};
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.set$span = function(value) { return this.span = value; };
 Value.prototype.get$_typeIsVarOrParameterType = function() {
-  return this.type.get$isVar() || (this.type instanceof ParameterType);
+  return $assert_bool(this.type.get$isVar() || (this.type instanceof ParameterType));
 }
 Value.prototype.get$isConst = function() {
   return false;
 }
+Value.prototype.get$canonicalCode = function() {
+  return null;
+}
 Value.prototype.get_ = function(context, name, node) {
   var member = this._resolveMember(context, name, node, false);
   if ($notnull_bool($ne(member, null))) {
     return member._get$3(context, node, this);
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name + ''), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
@@ skipping 30 matching lines @@
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
   if ($notnull_bool(this.get$_typeIsVarOrParameterType() && name == '\$ne')) {
     return true;
   }
   if ($notnull_bool(this.type.get$isVarOrFunction() && name == '\$call')) {
     return true;
   }
   var member = this._resolveMember(context, name, null, true);
-  return $ne(member, null) && member.canInvoke(context, args);
+  return $assert_bool($ne(member, null) && member.canInvoke(context, args));
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
   if ($notnull_bool(this.isSuper)) {
     var m = this.type.getMember('noSuchMethod');
-    return $ne(m, null) && !$notnull_bool(m.declaringType.get$isObject());
+    return $assert_bool($ne(m, null) && !$notnull_bool(m.declaringType.get$isObject()));
   }
   else {
     return this.type.resolveMember('noSuchMethod').members.length > 1;
   }
 }
 Value.prototype._tryResolveMember = function(context, name) {
   if ($notnull_bool(this.isSuper)) {
     return this.type.getMember(name);
   }
   else {
@@ skipping 46 matching lines @@
     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 = $assert_bool(this.type.get$isNum() && toType.get$isNum());
-    return fromType.isSubtypeOf(toType) || bothNum;
+    return $assert_bool(fromType.isSubtypeOf(toType) || bothNum);
   }
   return false;
 }
 Value.prototype.convertTo = function(context, toType, node, isDynamic) {
+  var $0;
   var checked = !$notnull_bool(isDynamic);
   var callMethod = toType.getCallMethod();
   if ($notnull_bool($ne(callMethod, null))) {
     if ($notnull_bool(checked && !$notnull_bool(toType.isAssignable(this.type)))) {
       this.convertWarning(toType, node);
     }
     var arity = callMethod.get$parameters().length;
     var myCall = this.type.getCallMethod();
     if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
       var stub = world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       var val = new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), node.span, false, true, false);
-      return $notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type))) ? val._wrapDomCallback(toType, arity) : val;
+      return (($0 = $notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type))) ? val._wrapDomCallback(toType, arity) : val) && $0.is$Value());
     }
     else if ($notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type)))) {
       return this._wrapDomCallback(toType, arity);
     }
   }
   var fromType = this.type;
   if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
     fromType = world.objectType;
   }
   var bothNum = $assert_bool(this.type.get$isNum() && toType.get$isNum());
@@ skipping 21 matching lines @@
     if ($notnull_bool(this.code.startsWith('\$notnull_bool'))) {
       return this;
     }
     else {
       world.gen.corejs.useNotNullBool = true;
       return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), this.span, false, true, false);
     }
   }
 }
 Value.prototype._isDomCallback = function(toType) {
-  return ((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom()));
+  return $assert_bool(((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom())));
 }
 Value.prototype._wrapDomCallback = function(toType, arity) {
   return new Value(toType, ('\$wrap_call\$' + arity + '(' + this.code + ')'), this.span, false, true, false);
 }
 Value.prototype._typeAssert = function(context, toType, node) {
   if ($notnull_bool((toType instanceof ParameterType))) {
     var p = (toType && toType.is$ParameterType());
     toType = p.extendsType;
   }
   if ($notnull_bool(toType.get$isObject() || toType.get$isVar())) {
     world.internalError(('We thought ' + this.type.name + ' is not a subtype of ' + toType.name + '?'));
   }
   if ($notnull_bool(toType.get$isNum())) toType = world.numType;
   var check;
-  if ($notnull_bool(toType.get$library().get$isCore() && toType.get$typeofName() != null)) {
+  if ($notnull_bool(toType.get$isVoid())) {
+    check = ('\$assert_void(' + this.code + ')');
+    if ($notnull_bool(toType.typeCheckCode == null)) {
+      toType.typeCheckCode = "function $assert_void(x) {\n  return x == null ? x : x.is$void(); // throws TypeError\n}";
+    }
+  }
+  else if ($notnull_bool(toType.get$library().get$isCore() && toType.get$typeofName() != null)) {
     check = ('\$assert_' + toType.name + '(' + this.code + ')');
     if ($notnull_bool(toType.typeCheckCode == null)) {
       toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  throw new TypeError(\"'\" + x + \"' is not a " + toType.name + ".\");\n}");
     }
   }
   else {
     toType.isTested = true;
     var temp = context.getTemp(this);
     check = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     check = check + (' ' + temp.code + '.is\$' + toType.get$jsname() + '())');
@@ skipping 35 matching lines @@
       testCode = '!' + testCode;
     }
     if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
   }
   return new Value(world.boolType, testCode, span, 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 $0;
   var pos = '';
   if ($notnull_bool(args != null)) {
     var argsCode = [];
     for (var i = 0;
      $notnull_bool(i < args.get$length()); i++) {
       argsCode.add(args.values.$index(i).code);
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), node.span, false, true, false), new Value(world.listType, ('[' + pos + ']'), node.span, false, true, false)];
-  return this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
+  return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 447, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 448, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 461, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 462, 12);
   var argsString = args.getCode();
   if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, false, true, false);
   }
   else {
     if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
     world.gen.corejs.useOperator(name);
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), this.span, false, true, false);
   }
 }
@@ skipping 12 matching lines @@
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
   return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
+EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
+EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 EvaluatedValue.codeWithComments = function(canonicalCode, span) {
   return $notnull_bool((span != null && span.get$text() != canonicalCode)) ? ('' + canonicalCode + '/*' + span.get$text() + '*/') : canonicalCode;
 }
 // ********** Code for ConstListValue **************
 function ConstListValue() {}
 ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
@@ skipping 47 matching lines @@
 function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, span, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.dependencies = dependencies;
   Value.call(this, type, code, span, false, !$notnull_bool(isConst), false);
   // Initializers done
 }
 $inherits(GlobalValue, Value);
+GlobalValue.prototype.is$GlobalValue = function(){return this;};
 GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
-  var code = ($notnull_bool(exp.get$isConst()) ? exp.canonicalCode : exp.code);
+  var code = ($notnull_bool(exp.get$isConst()) ? exp.get$canonicalCode() : exp.code);
   var codeWithComment = ('' + code + '/*' + field.declaringType.name + '.' + field.get$name() + '*/');
   return new GlobalValue(exp.type, $assert_String(codeWithComment), field.isFinal, field, null, exp, code, exp.span, dependencies.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
 GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
   var name = ("const\$" + uniqueId + "");
   var codeWithComment = ("" + name + "/*" + exp.span.get$text() + "*/");
   return new GlobalValue(exp.type, $assert_String(codeWithComment), true, null, name, exp, name, exp.span, dependencies.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$canonicalCode = function() { return this.canonicalCode; };
+GlobalValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 GlobalValue.prototype.get$isConst = function() {
-  return this.exp.get$isConst() && (this.field == null || this.field.isFinal);
+  return $assert_bool(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 ($notnull_bool($eq(other, this))) {
     return 0;
   }
   else if ($notnull_bool(this.dependencies.indexOf(other, 0) >= 0)) {
     return 1;
@@ skipping 21 matching lines @@
   }
 }
 // ********** Code for BareValue **************
 function BareValue(home, outermost, span) {
   this.home = home;
   Value.call(this, outermost.method.declaringType, null, span, false, false, outermost.get$isStatic());
   // Initializers done
 }
 $inherits(BareValue, Value);
 BareValue.prototype._tryResolveMember = function(context, name) {
-  $assert($eq(context, this.home), "context == home", "value.dart", 651, 12);
+  $assert($eq(context, this.home), "context == home", "value.dart", 665, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
-    $assert(this.code == null, "code == null", "value.dart", 656, 14);
+    $assert(this.code == null, "code == null", "value.dart", 670, 14);
     if ($notnull_bool(this.isType)) {
       this.code = this.type.get$jsname();
     }
     else {
       this.code = this.home._makeThisCode();
     }
     return member;
   }
   member = this.home.get$library().lookup(name, this.span);
   if ($notnull_bool($ne(member, null))) {
@@ skipping 24 matching lines @@
   this.seenFatal = false
   this.files = files;
   this.libraries = $map([]);
   this._todo = [];
   this._members = $map([]);
   this._topNames = $map([]);
   this.reader = new LibraryReader();
   // Initializers done
 }
 World.prototype.get$coreimpl = function() {
-  return this.libraries.$index('dart:coreimpl');
+  var $0;
+  return (($0 = this.libraries.$index('dart:coreimpl')) && $0.is$Library());
 }
 World.prototype.get$dom = function() {
-  return this.libraries.$index('dart:dom');
+  var $0;
+  return (($0 = this.libraries.$index('dart:dom')) && $0.is$Library());
 }
 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 = (($0 = this._addToCoreLib('void', false)) && $0.is$DefinedType());
   this.dynamicType = (($0 = this._addToCoreLib('Dynamic', false)) && $0.is$DefinedType());
@@ skipping 434 matching lines @@
 }
 ;
 // ********** Code for VarFunctionStub **************
 function VarFunctionStub(name, callArgs) {
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
   // Initializers done
   world.gen.corejs.useGenStub = true;
 }
 $inherits(VarFunctionStub, VarMember);
+VarFunctionStub.prototype.is$VarFunctionStub = function(){return this;};
 VarFunctionStub.prototype.generate = function(code) {
   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();
@@ skipping 19 matching lines @@
 // ********** Code for VarMethodStub **************
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodStub, VarMember);
 VarMethodStub.prototype.get$returnType = function() {
-  return $notnull_bool(this.member != null) ? this.member.get$returnType() : world.varType;
+  var $0;
+  return (($0 = $notnull_bool(this.member != null) ? this.member.get$returnType() : world.varType) && $0.is$lang_Type());
 }
 VarMethodStub.prototype.get$typeName = function() {
   return $notnull_bool(this.member != null) ? this.member.declaringType.get$jsname() : 'Object';
 }
 VarMethodStub.prototype.generate = function(code) {
   code.write(('' + this.get$typeName() + '.prototype.' + this.name + ' = '));
   this.generateBody(code);
   code.writeln(';');
 }
 VarMethodStub.prototype.generateBody = function(code) {
@@ skipping 29 matching lines @@
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$members = function() { return this.members; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
-  return this.members.$index(0).get$name();
+  return $assert_String(this.members.$index(0).get$name());
 }
 VarMethodSet.prototype.invoke = function(context, node, target, args) {
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if ($notnull_bool(this._fallbackStubs != null)) return;
   this._fallbackStubs = [];
   var $list = this.members;
   for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 80 matching lines @@
   })
   );
   var values = [];
   for (var $i = 0;$i < keys.length; $i++) {
     var k = keys.$index($i);
     values.add(map.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
-  return text.startsWith('"""') || text.startsWith("'''");
+  return $assert_bool(text.startsWith('"""') || text.startsWith("'''"));
 }
 function isRawMultilineString(text) {
-  return text.startsWith('@"""') || text.startsWith("@'''");
+  return $assert_bool(text.startsWith('@"""') || text.startsWith("@'''"));
 }
 function parseStringLiteral(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);
     }
   }
@@ skipping 36 matching lines @@
       var code = world.getGeneratedCode();
       if ($notnull_bool(!$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;
+  return $assert_bool(success);
 }
 var options;
 function parseOptions(homedir, args, files) {
   $assert(options == null, "options == null", "frog_options.dart", 10, 10);
   options = new FrogOptions(homedir, args, files);
 }
 function _getCallStubName(name, args) {
   var nameBuilder = new StringBufferImpl(('' + name + '\$' + args.get$bareCount() + ''));
   for (var i = args.get$bareCount();
    $notnull_bool(i < args.get$length()); i++) {
@@ skipping 146 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);