incremental progress on Value

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 880 matching lines @@
 
 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 && 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(); ) {
     var item = $i.next();
     this.add(item);
   }
 }
 ListFactory.prototype.clear = function() {
   this.length = 0;
 }
 ListFactory.prototype.removeLast = function() {
   return this.pop();
@@ skipping 652 matching lines @@
   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 && set.is$HashSetImplementation());
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
@@ skipping 375 matching lines @@
   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 && 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(); ) {
     var e = $i.next();
     this.add(e);
   }
 }
 DoubleLinkedQueue.prototype.removeLast = function() {
   return this._sentinel._previous.remove();
 }
 DoubleLinkedQueue.prototype.last = function() {
   return this._sentinel._previous.get$element();
 }
 DoubleLinkedQueue.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue.prototype.get$length = function() {
   var counter = 0;
   this.forEach(function _(element) {
     counter++;
   }
   );
   return counter;
 }
 Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
   get: DoubleLinkedQueue.prototype.get$length
 });
 DoubleLinkedQueue.prototype.isEmpty = function() {
-  return $assert_bool((this._sentinel._next === this._sentinel));
+  return (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 54 matching lines @@
   // Initializers done
   this._sentinel = new _DoubleLinkedQueueEntrySentinel$KeyValuePair$String$Keyword();
 }
 $inherits(DoubleLinkedQueue$KeyValuePair$String$Keyword, DoubleLinkedQueue);
 DoubleLinkedQueue$KeyValuePair$String$Keyword.prototype.is$Iterable = function(){return this;};
 // ********** Code for DoubleLinkedQueue$SourceString **************
 function DoubleLinkedQueue$SourceString() {}
 $inherits(DoubleLinkedQueue$SourceString, DoubleLinkedQueue);
 DoubleLinkedQueue$SourceString.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue$SourceString.DoubleLinkedQueue$from$factory = function(other) {
-  var $0;
   var list = new DoubleLinkedQueue();
   for (var $i = other.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     list.addLast(e);
   }
   return (list && 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 $assert_bool(this._currentEntry._next !== this._sentinel);
+  return 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) {
@@ skipping 54 matching lines @@
   return this._length == 0;
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString();
   if ($notnull_bool(str == null || str.isEmpty())) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
 }
 StringBufferImpl.prototype.addAll = function(objects) {
-  var $0;
   for (var $i = objects.iterator(); $i.hasNext(); ) {
     var obj = $i.next();
     this.add(obj);
   }
   return this;
 }
 StringBufferImpl.prototype.clear = function() {
   this._buffer = new ListFactory$String();
   this._length = 0;
   return this;
@@ skipping 68 matching lines @@
       this.hash_ = this.hash_ & ((1 << 29) - 1);
     }
     return this.hash_;
 }
 StringImplementation.prototype.compareTo = function(other) {
   return this == other ? 0 : this < other ? -1 : 1;
 }
 // ********** Code for Collections **************
 function Collections() {}
 Collections.forEach = function(iterable, f) {
-  var $0;
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     f(e);
   }
 }
 Collections.some = function(iterable, f) {
-  var $0;
   for (var $i = iterable.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     if ($notnull_bool(f(e))) return true;
   }
   return false;
 }
 Collections.filter = function(source, destination, f) {
-  var $0;
   for (var $i = source.iterator(); $i.hasNext(); ) {
     var e = $i.next();
     if ($notnull_bool(f(e))) destination.add(e);
   }
   return destination;
 }
 // ********** Code for DateImplementation **************
 function DateImplementation() {}
 DateImplementation.fromEpoch$ctor = function(value, timeZone) {
   this.value = value;
   this.timeZone = timeZone;
   // Initializers done
 }
 DateImplementation.fromEpoch$ctor.prototype = DateImplementation.prototype;
 DateImplementation.now$ctor = function() {
   this.timeZone = new TimeZoneImplementation.local$ctor();
   this.value = DateImplementation._now();
   // Initializers done
   this._asJs();
 }
 DateImplementation.now$ctor.prototype = DateImplementation.prototype;
 DateImplementation.prototype.get$value = function() { return this.value; };
 DateImplementation.prototype.$eq = function(other) {
   if ($notnull_bool(!$notnull_bool(((other instanceof DateImplementation))))) return false;
-  return $assert_bool((this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone)));
+  return $notnull_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 97 matching lines @@
   return {'require': require, 'process': process, 'console': console,
         'setTimeout': setTimeout, 'clearTimeout': clearTimeout};
 }
 //  ********** Library file_system **************
 // ********** Code for top level **************
 function joinPaths(path1, path2) {
   var pieces = path1.split('/');
   var $list = path2.split('/');
   for (var $i = 0;$i < $list.length; $i++) {
     var piece = $list.$index($i);
-    if ($notnull_bool($eq(piece, '..') && pieces.length > 0 && $ne(pieces.last(), '.') && $ne(pieces.last(), '..'))) {
+    if ($notnull_bool($eq(piece, '..') && pieces.length > 0) && $ne(pieces.last(), '.') && $ne(pieces.last(), '..')) {
       pieces.removeLast();
     }
     else if ($notnull_bool($ne(piece, ''))) {
       if ($notnull_bool(pieces.length > 0 && $eq(pieces.last(), '.'))) {
         pieces.removeLast();
       }
       pieces.add(piece);
     }
   }
   return Strings.join((pieces && pieces.is$List$String()), '/');
@@ skipping 258 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/)) {
+  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
     if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/)) {
+  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.get$head().kind !== openKind)) {
     if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
   this.groupingStack.get$head().endGroup = oldTail.next;
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendGtGt = function(kind, value) {
@@ skipping 76 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner$SourceString.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner$SourceString.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/)) {
+  while ($notnull_bool(kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
     if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/)) {
+  while ($notnull_bool(openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty())) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.get$head().kind !== openKind)) {
     if ($notnull_bool(openKind === 60/*null.LT_TOKEN*/)) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
   this.groupingStack.get$head().endGroup = oldTail.next;
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendGtGt = function(kind, value) {
@@ skipping 722 matching lines @@
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
   while ($notnull_bool(true)) {
     if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
       if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/)) {
+    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
     else if ($notnull_bool(next < 128)) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
@@ skipping 793 matching lines @@
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
   while ($notnull_bool(true)) {
     if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
       if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/)) {
+    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
     else if ($notnull_bool(next < 128)) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
@@ skipping 792 matching lines @@
     state = KeywordState.get$KEYWORD_STATE().next(next);
     next = this.advance();
   }
   var isAscii = true;
   while ($notnull_bool(true)) {
     if ($notnull_bool(97/*null.$a*/ <= next && next <= 122/*null.$z*/)) {
       if ($notnull_bool(state != null)) {
         state = state.next(next);
       }
     }
-    else if ($notnull_bool((48/*null.$0*/ <= next && next <= 57/*null.$9*/) || (65/*null.$A*/ <= next && next <= 90/*null.$Z*/) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/)) {
+    else if ($notnull_bool(($notnull_bool(48/*null.$0*/ <= next && next <= 57/*null.$9*/)) || ($notnull_bool(65/*null.$A*/ <= next && next <= 90/*null.$Z*/))) || next == 95/*null.$_*/ || next == 36/*null.$DOLLAR*/) {
       state = null;
     }
     else if ($notnull_bool(next < 128)) {
       if ($notnull_bool(state != null && state.isLeaf())) {
         this.appendKeywordToken(state.get$keyword());
       }
       else if ($notnull_bool(isAscii)) {
         this.appendByteStringToken(97/*null.IDENTIFIER_TOKEN*/, this.asciiString(start));
       }
       else {
@@ skipping 308 matching lines @@
   if ($notnull_bool(this.optional('factory', token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 PartialParser.prototype.skipBlock = function(token) {
   if ($notnull_bool(!$notnull_bool(this.optional('{', token)))) {
     return this.listener.expectedBlock(token);
   }
   var beginGroupToken = (token && token.is$BeginGroupToken());
-  $assert(beginGroupToken.endGroup == null || beginGroupToken.endGroup.kind === 125/*null.$RBRACE*/, "beginGroupToken.endGroup === null ||\n           beginGroupToken.endGroup.kind === $RBRACE", "parser.dart", 171, 12);
+  $assert($notnull_bool(beginGroupToken.endGroup == null || beginGroupToken.endGroup.kind === 125/*null.$RBRACE*/), "beginGroupToken.endGroup === null ||\n           beginGroupToken.endGroup.kind === $RBRACE", "parser.dart", 171, 12);
   return beginGroupToken.endGroup;
 }
 PartialParser.prototype.skipArguments = function(token) {
   return token.endGroup;
 }
 PartialParser.prototype.parseClass = function(token) {
   var begin = token;
   this.listener.beginClass(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
@@ skipping 67 matching lines @@
   if ($notnull_bool(this.optional('extends', token))) {
     token = this.parseType(this.next(token));
   }
   else {
     this.listener.handleNoType(token);
   }
   this.listener.endTypeVariable(token);
   return token;
 }
 PartialParser.prototype.optional = function(value, token) {
-  return $assert_bool(value === token.get$stringValue());
+  return 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 72 matching lines @@
       isField = true;
       break;
     }
     else {
       token = this.listener.unexpected(token);
     }
   }
   if ($notnull_bool(!$notnull_bool(isField))) {
     token = this.next(this.skipArguments((token && token.is$BeginGroupToken())));
   }
-  while ($notnull_bool(token != null && token.kind !== 123/*null.LBRACE_TOKEN*/ && token.kind !== 59/*null.SEMICOLON_TOKEN*/)) {
+  while ($notnull_bool(token != null && token.kind !== 123/*null.LBRACE_TOKEN*/) && token.kind !== 59/*null.SEMICOLON_TOKEN*/) {
     token = this.next(token);
   }
   if ($notnull_bool(!$notnull_bool(this.optional(';', token)))) {
     token = this.skipBlock(token);
   }
   if ($notnull_bool(isField)) {
     this.listener.endTopLevelField(start, token);
   }
   else {
     this.listener.endTopLevelMethod(start, token);
   }
   return token.next;
 }
 PartialParser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect('(', token);
-  while ($notnull_bool(token != null && token.kind !== 40/*null.LPAREN_TOKEN*/ && token.kind !== 41/*null.RPAREN_TOKEN*/)) {
+  while ($notnull_bool(token != null && token.kind !== 40/*null.LPAREN_TOKEN*/) && token.kind !== 41/*null.RPAREN_TOKEN*/) {
     token = this.next(token);
   }
   token = this.expect(')', token);
   return this.expect(';', token);
 }
 PartialParser.prototype.beginTypeArguments$1 = function($0) {
   return this.beginTypeArguments.call$1($0);
 }
 ;
 PartialParser.prototype.beginTypeVariables$1 = function($0) {
@@ skipping 148 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 $assert_bool(2 === this.getPrecedence(token));
+  return 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 943 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 $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return $notnull_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 $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return $notnull_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 12 matching lines @@
 }
 Keyword.prototype.is$Keyword = function(){return this;};
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
   if ($notnull_bool(Keyword._keywords == null)) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
-  var $0;
   var result = new LinkedHashMapImplementation$String$Keyword();
   for (var $i0 = const$234/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
     var keyword = $i0.next();
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
-  return $assert_bool(!!(other && other.is$SourceString) && this.toString() == other.toString());
+  return $notnull_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;
 }
@@ skipping 130 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 $assert_bool(this.beginToken.get$stringValue() === 'interface');
+  return 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 $assert_bool(this.argumentsNode == null);
+  return this.argumentsNode == null;
 }
 Send.prototype.get$isFunctionObjectInvocation = function() {
-  return $assert_bool(this.selector == null);
+  return this.selector == null;
 }
 Send.prototype.getBeginToken = function() {
   return firstBeginToken(this.receiver, this.selector);
 }
 Send.prototype.getEndToken = function() {
   var $0;
   var token;
   if ($notnull_bool(this.argumentsNode != null)) token = this.argumentsNode.getEndToken();
   if ($notnull_bool(token != null)) return token;
   if ($notnull_bool(this.selector != null)) {
@@ skipping 76 matching lines @@
 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 $assert_bool(this.elsePart != null);
+  return this.elsePart != null;
 }
 If.prototype.accept = function(visitor) {
   return visitor.visitIf(this);
 }
 If.prototype.getBeginToken = function() {
   return this.ifToken;
 }
 If.prototype.getEndToken = function() {
   if ($notnull_bool(this.elsePart == null)) return this.thenPart.getEndToken();
   return this.elsePart.getEndToken();
@@ skipping 187 matching lines @@
 }
 // ********** 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 $assert_bool(this.expression != null);
+  return 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;
 }
@@ skipping 353 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 $assert_bool(this.current == null);
+  return 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() {
   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());
     var identifierLink = container.definitions.nodes;
-    $assert(!$notnull_bool(identifierLink.isEmpty()) && identifierLink.get$tail().isEmpty(), "!identifierLink.isEmpty() && identifierLink.tail.isEmpty()", "builder.dart", 115, 14);
+    $assert($notnull_bool(!$notnull_bool(identifierLink.isEmpty()) && identifierLink.get$tail().isEmpty()), "!identifierLink.isEmpty() && identifierLink.tail.isEmpty()", "builder.dart", 115, 14);
     if ($notnull_bool(!(identifierLink.get$head() instanceof Identifier))) {
       this.compiler.unimplemented("SsaBuilder.visitParameters non-identifier");
     }
     var parameterId = (($0 = identifierLink.get$head()) && $0.is$Identifier());
     var element = (($0 = this.elements.$index(parameterId)) && $0.is$Element());
     var parameterInstruction = new HParameter(parameterIndex++);
     this.definitions.$setindex(element, parameterInstruction);
     this.add(parameterInstruction);
   }
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   var $0;
   for (var link = node.statements.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
     if ($notnull_bool(this.isAborted())) {
       if ($notnull_bool(!$notnull_bool(this.stack.isEmpty()))) this.compiler.cancel('non-empty instruction stack');
       return;
     }
   }
-  $assert(!(this.current.last instanceof HGoto) && !(this.current.last instanceof HReturn), "current.last is !HGoto && current.last is !HReturn", "builder.dart", 138, 12);
+  $assert($notnull_bool(!(this.current.last instanceof HGoto) && !(this.current.last instanceof HReturn)), "current.last is !HGoto && current.last is !HReturn", "builder.dart", 138, 12);
   if ($notnull_bool(!$notnull_bool(this.stack.isEmpty()))) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitClassNode = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitClassNode");
 }
 SsaBuilder.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
   this.pop();
 }
 SsaBuilder.prototype.visitFor = function(node) {
   var $this = this; // closure support
-  $assert(node.initializer != null && node.condition != null && node.update != null && node.body != null, "node.initializer !== null && node.condition !== null &&\n           node.update !== null && node.body !== null", "builder.dart", 152, 12);
+  $assert($notnull_bool(node.initializer != null && node.condition != null) && node.update != null && node.body != null, "node.initializer !== null && node.condition !== null &&\n           node.update !== null && node.body !== null", "builder.dart", 152, 12);
   this.visit(node.initializer);
   $assert(!$notnull_bool(this.isAborted()), "!isAborted()", "builder.dart", 156, 12);
   var initializerBlock = this.close(new HGoto());
   var initializerDefinitions = HashMapImplementation.HashMapImplementation$from$factory(this.definitions);
   var conditionBlock = this.graph.addNewBlock();
   conditionBlock.isLoopHeader = true;
   initializerBlock.addSuccessor(conditionBlock);
   this.open(conditionBlock);
   initializerDefinitions.forEach((function (element, instruction) {
     var phi = new HPhi(instruction, instruction);
@@ skipping 57 matching lines @@
   conditionExitBlock.addSuccessor(joinBlock);
   this.open(joinBlock);
   this.definitions = this.joinDefinitions(joinBlock, conditionDefinitions, this.definitions);
 }
 SsaBuilder.prototype.visitFunctionExpression = function(node) {
   this.compiler.unimplemented('SsaBuilder.visitFunctionExpression');
 }
 SsaBuilder.prototype.visitIdentifier = function(node) {
   var $0;
   var element = (($0 = this.elements.$index(node)) && $0.is$Element());
-  this.compiler.ensure($assert_bool(element != null));
+  this.compiler.ensure(element != null);
   var def = (($0 = this.definitions.$index(element)) && $0.is$HInstruction());
   $assert(def != null, "def !== null", "builder.dart", 253, 12);
   this.stack.add(def);
 }
 SsaBuilder.prototype.joinDefinitions = function(joinBlock, incoming1, incoming2) {
   if ($notnull_bool(incoming1.get$length() > incoming2.get$length())) {
     return this.joinDefinitions(joinBlock, incoming2, incoming1);
   }
   var joinedDefinitions = new HashMapImplementation$Element$HInstruction();
   $assert(incoming1.get$length() <= incoming2.get$length(), "incoming1.length <= incoming2.length", "builder.dart", 272, 12);
@@ skipping 26 matching lines @@
   var thenDefinitions = this.definitions;
   this.definitions = conditionDefinitions;
   var elseBlock = null;
   if ($notnull_bool(hasElse)) {
     elseBlock = this.graph.addNewBlock();
     conditionBlock.addSuccessor(elseBlock);
     this.open(elseBlock);
     this.visit(node.elsePart);
     elseBlock = this.current;
   }
-  if ($notnull_bool(thenBlock == null && elseBlock == null && hasElse)) {
+  if ($notnull_bool(thenBlock == null && elseBlock == null) && hasElse) {
     this.current = null;
   }
   else {
     var joinBlock = this.graph.addNewBlock();
     if ($notnull_bool(thenBlock != null)) this.goto(thenBlock, joinBlock);
     if ($notnull_bool(elseBlock != null)) this.goto(elseBlock, joinBlock);
     else if ($notnull_bool(!$notnull_bool(hasElse))) conditionBlock.addSuccessor(joinBlock);
     this.open(joinBlock);
     if ($notnull_bool(joinBlock.predecessors.length == 2)) {
       this.definitions = this.joinDefinitions(joinBlock, this.definitions, thenDefinitions);
@@ skipping 105 matching lines @@
 }
 SsaBuilder.prototype.visitTypeAnnotation = function(node) {
 
 }
 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", 456, 12);
+  $assert($notnull_bool(!$notnull_bool(link.isEmpty()) && link.get$tail().isEmpty()), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 456, 12);
   this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
   this.definitions.$setindex(this.elements.$index(node), value);
   return value;
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var definition = (($0 = link.get$head()) && $0.is$Node());
@@ skipping 499 matching lines @@
   return id;
 }
 HBasicBlock.prototype.accept = function(visitor) {
   return visitor.visitBasicBlock(this);
 }
 HBasicBlock.prototype.add = function(instruction) {
   $assert(!(instruction instanceof HControlFlow), "instruction is !HControlFlow", "nodes.dart", 238, 12);
   this.addAfter(this.last, instruction);
 }
 HBasicBlock.prototype.addSuccessor = function(block) {
-  $assert(this.isClosed() && (block.isNew() || block.id < this.id), "isClosed() && (block.isNew() || block.id < id)", "nodes.dart", 244, 12);
+  $assert($notnull_bool(this.isClosed() && ($notnull_bool(block.isNew() || block.id < this.id))), "isClosed() && (block.isNew() || block.id < id)", "nodes.dart", 244, 12);
   if ($notnull_bool(this.successors.isEmpty())) {
     this.successors = [block];
   }
   else {
     this.successors.add(block);
   }
   block.predecessors.add(this);
 }
 HBasicBlock.prototype.addAfter = function(cursor, instruction) {
-  $assert(this.isOpen() || this.isClosed(), "isOpen() || isClosed()", "nodes.dart", 254, 12);
+  $assert($notnull_bool(this.isOpen() || this.isClosed()), "isOpen() || isClosed()", "nodes.dart", 254, 12);
   if ($notnull_bool(cursor == null)) {
     this.first = this.last = instruction;
   }
   else if ($notnull_bool(cursor === this.last)) {
     this.last.next = instruction;
     instruction.previous = this.last;
     this.last = instruction;
   }
   else {
     instruction.previous = cursor;
     instruction.next = cursor.next;
     cursor.next.previous = instruction;
     cursor.next = instruction;
   }
   instruction.notifyAddedToBlock();
 }
 HBasicBlock.prototype.remove = function(instruction) {
-  $assert(this.isOpen() || this.isClosed(), "isOpen() || isClosed()", "nodes.dart", 271, 12);
+  $assert($notnull_bool(this.isOpen() || this.isClosed()), "isOpen() || isClosed()", "nodes.dart", 271, 12);
   $assert(instruction.isInBasicBlock(), "instruction.isInBasicBlock()", "nodes.dart", 272, 12);
   $assert(instruction.get$usedBy().isEmpty(), "instruction.usedBy.isEmpty()", "nodes.dart", 273, 12);
   if ($notnull_bool(instruction.previous == null)) {
     this.first = instruction.next;
   }
   else {
     instruction.previous.next = instruction.next;
   }
   if ($notnull_bool(instruction.next == null)) {
     this.last = instruction.previous;
@@ skipping 13 matching lines @@
   from._usedBy = [];
 }
 HBasicBlock.rewriteInput = function(instruction, from, to) {
   var inputs = instruction.inputs;
   for (var i = 0;
    $notnull_bool(i < inputs.length); i++) {
     if ($notnull_bool(inputs.$index(i) === from)) inputs.$setindex(i, to);
   }
 }
 HBasicBlock.prototype.isExitBlock = function() {
-  return $assert_bool(this.first === this.last && (this.first instanceof HExit));
+  return $notnull_bool(this.first === this.last && (this.first instanceof HExit));
 }
 HBasicBlock.prototype.addDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 313, 12);
-  $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 314, 12);
+  $assert($notnull_bool(this.id != null && block.id != null), "id !== null && block.id !== null", "nodes.dart", 314, 12);
   $assert(this.dominatedBlocks.indexOf(block) < 0, "dominatedBlocks.indexOf(block) < 0", "nodes.dart", 315, 12);
   var index = this.dominatedBlocks.length;
   while ($notnull_bool(index > 0 && this.dominatedBlocks.$index(index - 1).id > block.id)) {
     index--;
   }
   if ($notnull_bool(index == this.dominatedBlocks.length)) {
     this.dominatedBlocks.add(block);
   }
   else {
     this.dominatedBlocks.insertRange(index, 1, block);
   }
   $assert(block.dominator == null, "block.dominator === null", "nodes.dart", 328, 12);
   block.dominator = this;
 }
 HBasicBlock.prototype.removeDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 333, 12);
-  $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 334, 12);
+  $assert($notnull_bool(this.id != null && block.id != null), "id !== null && block.id !== null", "nodes.dart", 334, 12);
   var index = this.dominatedBlocks.indexOf(block);
   $assert(index >= 0, "index >= 0", "nodes.dart", 336, 12);
   if ($notnull_bool(index == this.dominatedBlocks.length - 1)) {
     this.dominatedBlocks.removeLast();
   }
   else {
     this.dominatedBlocks.removeRange(index, 1);
   }
   $assert(block.dominator === this, "block.dominator === this", "nodes.dart", 342, 12);
   block.dominator = null;
 }
 HBasicBlock.prototype.assignCommonDominator = function(predecessor) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 347, 12);
   if ($notnull_bool(this.dominator == null)) {
     predecessor.addDominatedBlock(this);
   }
   else if ($notnull_bool(predecessor.dominator != null)) {
     var first = this.dominator;
     var second = predecessor;
     while ($notnull_bool(first !== second)) {
       if ($notnull_bool(first.id > second.id)) {
         first = first.dominator;
       }
       else {
         second = second.dominator;
       }
-      $assert(first != null && second != null, "first !== null && second !== null", "nodes.dart", 364, 16);
+      $assert($notnull_bool(first != null && second != null), "first !== null && second !== null", "nodes.dart", 364, 16);
     }
     if ($notnull_bool(this.dominator !== first)) {
       this.dominator.removeDominatedBlock(this);
       first.addDominatedBlock(this);
     }
   }
 }
 // ********** Code for HInstruction **************
 function HInstruction(inputs) {
   this._usedBy = null
@@ skipping 33 matching lines @@
   this.setFlag(2/*HInstruction.FLAG_GENERATE_AT_USE_SITE*/);
 }
 HInstruction.prototype.setUseGvn = function() {
   this.setFlag(3/*HInstruction.FLAG_USE_GVN*/);
 }
 HInstruction.prototype.get$usedBy = function() {
   if ($notnull_bool(this._usedBy == null)) return const$15/*const []*/;
   return this._usedBy;
 }
 HInstruction.prototype.isInBasicBlock = function() {
-  return $assert_bool(this._usedBy != null);
+  return this._usedBy != null;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
   $assert(!$notnull_bool(this.isInBasicBlock()), "!isInBasicBlock()", "nodes.dart", 472, 12);
   this._usedBy = [];
   for (var i = 0;
    $notnull_bool(i < this.inputs.length); i++) {
     $assert(this.inputs.$index(i).isInBasicBlock(), "inputs[i].isInBasicBlock()", "nodes.dart", 476, 14);
     this.inputs.$index(i).get$usedBy().add(this);
   }
   $assert(this.isValid(), "isValid()", "nodes.dart", 479, 12);
@@ skipping 357 matching lines @@
   }
   return this.visitArithmetic(node);
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
-  return $assert_bool(!$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty());
+  return $notnull_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 271 matching lines @@
   }
   if ($notnull_bool((block.last instanceof HIf) && block.successors.length != 2)) {
     this.markInvalid("If node without two successors");
   }
   if ($notnull_bool((block.last instanceof HConditionalBranch) && block.successors.length != 2)) {
     this.markInvalid("Conditional node without two successors");
   }
   if ($notnull_bool((block.last instanceof HGoto) && block.successors.length != 1)) {
     this.markInvalid("Goto node without one successor");
   }
-  if ($notnull_bool((block.last instanceof HReturn) && (block.successors.length != 1 || !$notnull_bool(block.successors.$index(0).isExitBlock())))) {
+  if ($notnull_bool((block.last instanceof HReturn) && ($notnull_bool(block.successors.length != 1 || !$notnull_bool(block.successors.$index(0).isExitBlock()))))) {
     this.markInvalid("Return node with > 1 succesor or not going to exit-block");
   }
   if ($notnull_bool((block.last instanceof HExit) && !$notnull_bool(block.successors.isEmpty()))) {
     this.markInvalid("Exit block with successor");
   }
   if ($notnull_bool((block.last instanceof HThrow) && !$notnull_bool(block.successors.isEmpty()))) {
     this.markInvalid("Throw block with successor");
   }
-  if ($notnull_bool(block.successors.isEmpty() && !(block.last instanceof HThrow) && !$notnull_bool(block.isExitBlock()))) {
+  if ($notnull_bool(block.successors.isEmpty() && !(block.last instanceof HThrow)) && !$notnull_bool(block.isExitBlock())) {
     this.markInvalid("Non-exit or throw block without successor");
   }
   if ($notnull_bool(block.id == null)) this.markInvalid("block without id");
   var $list = block.successors;
   for (var $i = 0;$i < $list.length; $i++) {
     var successor = $list.$index($i);
     if ($notnull_bool(!$notnull_bool(this.isValid))) break;
     if ($notnull_bool(successor.id == null)) this.markInvalid("successor without id");
     if ($notnull_bool(successor.id <= block.id && !$notnull_bool(successor.isLoopHeader))) {
       this.markInvalid("successor with lower id, but not a loop-header");
@@ skipping 55 matching lines @@
     })
     );
   }
   function hasCorrectUses(instruction) {
     if ($notnull_bool(!$notnull_bool(instruction.isInBasicBlock()))) return true;
     return HValidator.everyInstruction(instruction.get$usedBy(), (function (use, count) {
       return HValidator.countInstruction(use.inputs, (instruction && instruction.is$HInstruction())) == count;
     })
     );
   }
-  this.isValid = $assert_bool(this.isValid && hasCorrectInputs(instruction) && hasCorrectUses(instruction));
+  this.isValid = $notnull_bool(this.isValid && hasCorrectInputs(instruction)) && hasCorrectUses(instruction);
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldCompiler **************
 function WorldCompiler(world, script) {
   this.world = world;
   Compiler.call(this, script);
   // Initializers done
 }
 $inherits(WorldCompiler, Compiler);
@@ skipping 233 matching lines @@
   this.visit(node.condition);
   this.visit(node.thenPart);
   this.visit(node.elsePart);
 }
 ResolverVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = null;
   this.visit(node.receiver);
   var selector = (($0 = node.selector) && $0.is$Identifier());
   var name = selector.get$source();
-  if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$248/*const SourceString('-')*/) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/) || $eq(name, const$253/*const SourceString('==')*/))) {
+  if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$248/*const SourceString('-')*/)) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/) || $eq(name, const$253/*const SourceString('==')*/)) {
   }
   else {
     target = this.context.lookup(name);
     if ($notnull_bool(target == null)) this.fail(node, ErrorMessages.cannotResolve(name));
   }
   this.visit(node.argumentsNode);
   return this.useElement(node, target);
 }
 ResolverVisitor.prototype.visitSendSet = function(node) {
   var $0;
@@ skipping 44 matching lines @@
   }
   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.compiler.ensure(element != null);
   this.mapping.$setindex(node, element);
   return (($0 = this.context.add(element)) && $0.is$Element());
 }
 ResolverVisitor.prototype.useElement = function(node, element) {
   if ($notnull_bool(element == null)) return null;
   this.mapping.$setindex(node, element);
   return element;
 }
 // ********** Code for VariableDefinitionsVisitor **************
 function VariableDefinitionsVisitor(definitions, resolver) {
@@ skipping 171 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 $assert_bool(r === s || r === this.dynamicType || s === this.dynamicType);
+  return $notnull_bool(r === s || r === this.dynamicType) || s === this.dynamicType;
 }
 Types.prototype.isAssignable = function(r, s) {
-  return $assert_bool(this.isSubtype(r, s) || this.isSubtype(s, r));
+  return $notnull_bool(this.isSubtype(r, s) || this.isSubtype(s, r));
 }
 // ********** Code for CancelTypeCheckException **************
 function CancelTypeCheckException(node, reason) {
   this.node = node;
   this.reason = reason;
   // Initializers done
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(compiler, elements, types) {
   this.compiler = compiler;
@@ skipping 95 matching lines @@
       }
       if ($notnull_bool(!$notnull_bool(arguments.isEmpty()))) {
         this.compiler.reportWarning(arguments.get$head(), 'additional arguments');
       }
       return funType.returnType;
     }
   }
   else {
     var selector = (($0 = node.selector) && $0.is$Identifier());
     var name = selector.get$source();
-    if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$257/*const SourceString('=')*/) || $eq(name, const$248/*const SourceString('-')*/) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/))) {
+    if ($notnull_bool($eq(name, const$247/*const SourceString('+')*/) || $eq(name, const$257/*const SourceString('=')*/)) || $eq(name, const$248/*const SourceString('-')*/) || $eq(name, const$249/*const SourceString('*')*/) || $eq(name, const$250/*const SourceString('/')*/) || $eq(name, const$251/*const SourceString('<')*/) || $eq(name, const$252/*const SourceString('~/')*/)) {
       return this.types.dynamicType;
     }
     this.fail(node, ('unresolved send ' + name + ''));
   }
 }
 TypeCheckerVisitor.prototype.visitSendSet = function(node) {
   var $0;
-  this.compiler.ensure($assert_bool(node.get$arguments() != null && !$notnull_bool(node.get$arguments().isEmpty())));
+  this.compiler.ensure($notnull_bool(node.get$arguments() != null && !$notnull_bool(node.get$arguments().isEmpty())));
   var targetType = (($0 = this.elements.$index(node).computeType(this.compiler, this.types)) && $0.is$Type());
   var value = (($0 = node.get$arguments().get$head()) && $0.is$Node());
   this.checkAssignable(value, this.type(value), targetType);
   return targetType;
 }
 TypeCheckerVisitor.prototype.visitLiteralInt = function(node) {
   return this.types.intType;
 }
 TypeCheckerVisitor.prototype.visitLiteralDouble = function(node) {
   return this.types.dynamicType;
@@ skipping 47 matching lines @@
 TypeCheckerVisitor.prototype.visitVariableDefinitions = function(node) {
   var $0;
   var type = this.typeWithDefault(node.type, this.types.dynamicType);
   if ($notnull_bool($eq(type, this.types.voidType))) {
     this.compiler.reportWarning(node.type, CompilerError.voidVariable());
     type = this.types.dynamicType;
   }
   for (var link = node.definitions.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var initialization = (($0 = link.get$head()) && $0.is$Node());
-    this.compiler.ensure($assert_bool((initialization instanceof Identifier) || (initialization instanceof Send)));
+    this.compiler.ensure($notnull_bool((initialization instanceof Identifier) || (initialization instanceof Send)));
     if ($notnull_bool((initialization instanceof Send))) {
       var initializer = this.nonVoidType((($0 = link.get$head()) && $0.is$Node()));
       this.checkAssignable(node, type, initializer);
     }
   }
   return null;
 }
 // ********** Code for Universe **************
 function Universe() {
   this.elements = $map([]);
@@ skipping 277 matching lines @@
     if ($notnull_bool(type.get$isFunction() && type.varStubs != null)) {
       this.writer.comment(('// ********** Code for ' + type.get$jsname() + ' **************'));
       this._writeDynamicStubs((type && type.is$lang_Type()));
     }
     if ($notnull_bool(type.typeCheckCode != null)) {
       this.writer.writeln(type.typeCheckCode);
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
-  if ($notnull_bool(!$notnull_bool(meth.isGenerated) && !$notnull_bool(meth.get$isAbstract()) && $ne(meth.get$definition(), null))) {
+  if ($notnull_bool(!$notnull_bool(meth.isGenerated) && !$notnull_bool(meth.get$isAbstract())) && $ne(meth.get$definition(), null)) {
     new MethodGenerator(meth, enclosingMethod).run();
   }
 }
 WorldGenerator.prototype._maybeIsTest = function(onType, checkType) {
   if ($notnull_bool(!$notnull_bool(checkType.isTested))) return;
   var value = 'false';
   if ($notnull_bool(onType.isSubtypeOf(checkType))) {
     value = 'function(){return this;}';
   }
   this.writer.writeln(('' + onType.get$jsname() + '.prototype.is\$' + checkType.get$jsname() + ' = ') + ('' + value + ';'));
 }
 WorldGenerator.prototype.writeType = function(type) {
   var $0;
-  if ($notnull_bool(type.name != null && (type instanceof ConcreteType) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory'))) {
+  if ($notnull_bool(type.name != null && (type instanceof ConcreteType)) && $eq(type.get$library(), world.get$coreimpl()) && type.name.startsWith('ListFactory')) {
     this.writer.writeln(('' + type.get$jsname() + ' = ' + type.get$genericType().get$jsname() + ';'));
     return;
   }
   var typeName = $notnull_bool(type.get$jsname() != null) ? type.get$jsname() : 'top level';
   this.writer.comment(('// ********** Code for ' + typeName + ' **************'));
   if ($notnull_bool(type.get$isNativeType() && !$notnull_bool(type.get$isTop()))) {
     var nativeName = type.get$definition().get$nativeType();
     if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
@@ skipping 110 matching lines @@
     var value = this.globals.$index(fullname);
     if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative))) {
       this.writer.writeln(('var ' + field.get$jsname() + ' = ' + value.exp.code + ';'));
     }
     else {
       this.writer.writeln(('' + field.declaringType.get$jsname() + '.' + field.get$jsname() + ' = ' + value.exp.code + ';'));
     }
   }
 }
 WorldGenerator.prototype._writeField = function(field) {
-  if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative) && field.value == null)) {
+  if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative)) && field.value == null) {
     this.writer.writeln(('var ' + field.get$jsname() + ';'));
   }
   if ($notnull_bool(field._providePropertySyntax)) {
     this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.get\$' + field.get$jsname() + ' = ') + ('function() { return this.' + field.get$jsname() + '; };'));
     if ($notnull_bool(!$notnull_bool(field.isFinal))) {
       this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.set\$' + field.get$jsname() + ' = ') + ('function(value) { return this.' + field.get$jsname() + ' = value; };'));
     }
   }
 }
 WorldGenerator.prototype._writeProperty = function(property) {
@@ skipping 13 matching lines @@
 }
 WorldGenerator.prototype._writeMethod = function(method) {
   if ($notnull_bool(method.generator != null)) {
     method.generator.writeDefinition(this.writer, null);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return WorldGenerator.prototype._writeMethod.bind(this);
 }
 WorldGenerator.prototype._writeGlobals = function() {
-  var $0;
   if ($notnull_bool(this.globals.get$length() > 0)) {
     this.writer.comment('//  ********** Globals **************');
   }
   var list = this.globals.getValues();
   list.sort((function (a, b) {
     return a.compareTo(b);
   })
   );
   for (var $i = list.iterator(); $i.hasNext(); ) {
     var global = $i.next();
@@ skipping 37 matching lines @@
 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);
+    this.reentrant = $notnull_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.is$BlockScope = function(){return this;};
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
-  return $assert_bool(this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod));
+  return $notnull_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 && 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;
@@ skipping 14 matching lines @@
   if ($notnull_bool(this.get$isMethodScope() && this._closedOver.contains(name))) return true;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
     if ($notnull_bool(s._vars.containsKey(name))) return true;
     if ($notnull_bool(s.get$isMethodScope() && s._closedOver.contains(name))) return true;
   }
   var type = this.enclosingMethod.method.declaringType;
   if ($notnull_bool(type.get$library().lookup(name, null) != null)) return true;
   return false;
 }
-BlockScope.prototype.create = function(name, type, location, isParameter) {
+BlockScope.prototype.create = function(name, type, span, isParameter) {
   var jsName = world.toJsIdentifier(name);
   if ($notnull_bool(this._vars.containsKey(name))) {
-    if ($notnull_bool(location != null)) {
-      world.error(('duplicate name "' + name + '"'), location.span);
-    }
-    else {
-      world.internalError(('conflict with temporary name "' + name + '"'));
-    }
+    world.error(('duplicate name "' + name + '"'), span);
   }
   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);
+  var ret = new Value(type, jsName, span, false);
   this._vars.$setindex(name, ret);
   return (ret && ret.is$Value());
 }
 BlockScope.prototype.declareParameter = function(p) {
-  return this.create(p.name, p.type, p.definition, true);
+  return this.create(p.name, p.type, p.definition.span, 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);
+  return this.create(id.name.name, (type && type.is$lang_Type()), id.span, false);
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
   while ($notnull_bool(scope.rethrow == null && $ne(scope.get$parent(), null))) {
     scope = scope.get$parent();
   }
   return scope.rethrow;
 }
 // ********** Code for MethodGenerator **************
 function MethodGenerator(method, enclosingMethod) {
   var $0;
   this.method = method;
   this.enclosingMethod = enclosingMethod;
   this.writer = new CodeWriter();
   this.needsThis = false;
   // Initializers done
   if ($notnull_bool(this.enclosingMethod != null)) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
   if ($notnull_bool(this.enclosingMethod != null && this.method.name != '')) {
     var m = (($0 = this.method) && $0.is$MethodMember());
-    this._scope.create(m.name, m.get$functionType(), m.definition, false);
+    this._scope.create(m.name, m.get$functionType(), m.definition.span, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
 MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.get$library = function() {
   return this.method.get$library();
 }
 MethodGenerator.prototype.findMembers = function(name) {
   return this.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.get$isStatic = function() {
   return this.method.get$isStatic();
 }
 MethodGenerator.prototype.getTemp = function(value) {
   return $notnull_bool(value.needsTemp) ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
   if ($notnull_bool(this._freeTemps.length > 0)) {
     name = $assert_String(this._freeTemps.removeLast());
   }
   else {
     name = '\$' + this._usedTemps.get$length();
   }
   this._usedTemps.add(name);
-  return new Value(value.type, name, value.span, false, false, false);
+  return new Value(value.type, name, value.span, false);
 }
 MethodGenerator.prototype.assignTemp = function(tmp, v) {
   if ($notnull_bool($eq(tmp, v))) {
     return v;
   }
   else {
-    return new Value(v.type, ('(' + tmp.code + ' = ' + v.code + ')'), v.span, false, true, false);
+    return new Value(v.type, ('(' + tmp.code + ' = ' + v.code + ')'), v.span, true);
   }
 }
 MethodGenerator.prototype.freeTemp = function(value) {
   if ($notnull_bool(this._usedTemps.remove(value.code))) {
     this._freeTemps.add(value.code);
   }
   else {
     world.internalError(('tried to free unused value or non-temp "' + value.code + '"'));
   }
 }
@@ skipping 65 matching lines @@
   else if ($notnull_bool(this.method.get$isStatic())) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.') + ('' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
   if ($notnull_bool(this._usedTemps.get$length() > 0 || this._freeTemps.length > 0)) {
-    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 701, 14);
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 695, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if ($notnull_bool($ne(names, null))) {
     defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
@@ skipping 77 matching lines @@
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     if ($notnull_bool($ne(initializers, null) && p.isInitializer)) {
       var field = this.method.declaringType.getMember(p.get$name());
       if ($notnull_bool(field == null)) {
         world.error('bad this parameter - no matching field', p.get$definition().get$span());
       }
       if ($notnull_bool(!$notnull_bool(field.get$isField()))) {
         world.error(('"this.' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
-      var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false, false, false);
+      var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false);
       this._paramCode.add(paramValue.code);
       initializers.add(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
       initializedFields.add(p.get$name());
     }
     else {
       var paramValue = this._scope.declareParameter((p && p.is$Parameter()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
@@ skipping 11 matching lines @@
       for (var $i = 0;$i < declaredInitializers.length; $i++) {
         var init = declaredInitializers.$index($i);
         if ($notnull_bool((init instanceof CallExpression))) {
           if ($notnull_bool($ne(initializerCall, null))) {
             world.error('only one initializer redirecting call is allowed', init.get$span());
           }
           initializerCall = init;
         }
         else if ($notnull_bool((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0)) {
           var left = init.x;
-          if ($notnull_bool(!$notnull_bool(((left instanceof DotExpression) && (left.self instanceof ThisExpression) || (left instanceof VarExpression))))) {
+          if ($notnull_bool(!$notnull_bool(($notnull_bool((left instanceof DotExpression) && (left.self instanceof ThisExpression)) || (left instanceof VarExpression))))) {
             world.error('invalid left side of initializer', left.get$span());
             continue;
           }
           initializedFields.add(left.get$name().get$name());
           var assign = this._makeThisValue(null).set_(this, $assert_String(left.get$name().get$name()), (($0 = left.get$name()) && $0.is$lang_Node()), (($0 = this.visitValue(init.y)) && $0.is$Value()), false);
           this.writer.writeln(('' + assign.code + ';'));
         }
         else {
           world.error('invalid initializer', init.get$span());
         }
@@ skipping 21 matching lines @@
       else {
       }
     }
     this.writer.comment('// Initializers done');
   }
   if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.get$members().getKeys();
     for (var $i = this.method.declaringType.get$members().getKeys().iterator(); $i.hasNext(); ) {
       var name = $i.next();
       var member = this.method.declaringType.get$members().$index(name);
-      if ($notnull_bool((member instanceof FieldMember) && member.isFinal && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains(name)))) {
+      if ($notnull_bool((member instanceof FieldMember) && member.isFinal) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains(name))) {
         world.error(('Field "' + name + '" is final and was not initialized'), this.method.get$definition().get$span());
       }
     }
   }
   this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
   if ($notnull_bool((targetExp instanceof DotExpression))) {
@@ skipping 116 matching lines @@
     var name = node.names.$index(i).get$name();
     var value = this.visitValue((($0 = node.values.$index(i)) && $0.is$lang_Expression()));
     if ($notnull_bool(isFinal)) {
       if ($notnull_bool(value == null)) {
         world.error('no value specified for final variable', node.span);
       }
       else {
         if ($notnull_bool(thisType.get$isVar())) thisType = value.type;
       }
     }
-    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), (($0 = node.names.$index(i)) && $0.is$lang_Node()), false);
+    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), node.names.$index(i).get$span(), false);
     if ($notnull_bool(value == null)) {
       this.writer.write(('' + val.code + ''));
     }
     else {
       value = value.convertTo(this, (type && type.is$lang_Type()), (($0 = node.values.$index(i)) && $0.is$lang_Node()), false);
       this.writer.write(('' + val.code + ' = ' + value.code + ''));
     }
   }
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var $0;
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod($assert_String(name), node);
-  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), (($0 = this.method.get$definition()) && $0.is$lang_Node()), false);
+  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), this.method.get$definition().get$span(), false);
   meth.generator.writeDefinition(this.writer, null);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if ($notnull_bool(node.value == null)) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
@@ skipping 110 matching lines @@
   this._popBlock();
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
   var $0;
   var itemType = this.method.resolveType(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
-  var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$lang_Type()), node.item.name, false);
+  var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$lang_Type()), node.item.name.span, false);
   var listVar = (list && list.is$Value());
   if ($notnull_bool(list.needsTemp)) {
     listVar = this._scope.create('\$list', (($0 = list.type) && $0.is$lang_Type()), null, false);
     this.writer.writeln(('var ' + listVar.code + ' = ' + list.code + ';'));
   }
   if ($notnull_bool(list.type.get$isList())) {
     var tmpi = this._scope.create('\$i', world.numType, null, false);
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = 0;') + ('' + tmpi.code + ' < ' + listVar.code + '.length; ' + tmpi.code + '++) {'));
     var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), false);
     this.writer.writeln(('var ' + item.code + ' = ' + value.code + ';'));
   }
   else {
     this._pushBlock(false);
-    var c = world.get$coreimpl().types.$index('ListIterator').getConstructor('');
-    c.invoke$4(this, node, null, new Arguments(null, [new Value(null, 'l', node.list.span, false, true, false)]));
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
     var tmpi = this._scope.create('\$i', (($0 = iterator.type) && $0.is$lang_Type()), null, false);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
     this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
     this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex, node) {
-  var $0;
   var types = const$403/*const [
         'NullPointerException', 'ObjectNotClosureException',
         'NoSuchMethodException', 'StackOverflowException']*/;
-  var target = new Value(null, 'this', node.span, false, true, false);
+  var target = new Value(world.varType, 'this', node.span, true);
   for (var $i = types.iterator(); $i.hasNext(); ) {
     var name = $i.next();
     world.corelib.types.$index(name).markUsed();
     world.corelib.types.$index(name).get$members().$index('toString').invoke$4(this, node, target, Arguments.get$EMPTY());
   }
   this.writer.writeln(('' + ex + ' = \$toDartException(' + ex + ');'));
   world.gen.corejs.useToDartException = true;
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   var $0;
@@ skipping 164 matching lines @@
   if ($notnull_bool(this.get$isStatic())) {
     world.warning('not allowed in static method', node.span);
   }
 }
 MethodGenerator.prototype._makeSuperValue = function(node) {
   var parentType = this.method.declaringType.get$parent();
   this._checkNonStatic(node);
   if ($notnull_bool(parentType == null)) {
     world.error('no super class', node.span);
   }
-  return new Value(parentType, 'this', node.span, true, false, false);
+  var ret = new Value(parentType, 'this', node.span, false);
+  ret.isSuper = true;
+  return ret;
 }
 MethodGenerator.prototype._getOutermostMethod = function() {
   var result = this;
   while ($notnull_bool(result.enclosingMethod != null)) {
     result = result.enclosingMethod;
   }
   return result;
 }
 MethodGenerator.prototype._makeThisCode = function() {
   if ($notnull_bool(this.enclosingMethod != null)) {
     this._getOutermostMethod().needsThis = true;
     return '\$this';
   }
   else {
     return 'this';
   }
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
   if ($notnull_bool(this.enclosingMethod != null)) {
     var outermostMethod = this._getOutermostMethod();
     outermostMethod._checkNonStatic(node);
     outermostMethod.needsThis = true;
-    return new Value(outermostMethod.method.declaringType, '\$this', $notnull_bool(node != null) ? node.span : null, false, false, false);
+    return new Value(outermostMethod.method.declaringType, '\$this', $notnull_bool(node != null) ? node.span : null, false);
   }
   else {
     this._checkNonStatic(node);
-    return new Value(this.method.declaringType, 'this', $notnull_bool(node != null) ? node.span : null, false, false, false);
+    return new Value(this.method.declaringType, 'this', $notnull_bool(node != null) ? node.span : null, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = '';
   if ($notnull_bool(node.func.name != null)) {
     name = world.toJsIdentifier(node.func.name.name);
   }
   var meth = this._makeLambdaMethod($assert_String(name), node.func);
   var w = new CodeWriter();
   meth.generator.writeDefinition((w && w.is$CodeWriter()), node);
-  return new Value(meth.get$functionType(), w.get$text(), node.span, false, true, false);
+  return new Value(meth.get$functionType(), w.get$text(), node.span, true);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
   var $0;
   var target;
   var position = node.target;
   var name = '\$call';
   if ($notnull_bool((node.target instanceof DotExpression))) {
     var dot = (($0 = node.target) && $0.is$DotExpression());
     target = dot.self.visit(this);
     name = dot.name.name;
@@ skipping 20 matching lines @@
   return target.invoke$4(this, '\$index', node, new Arguments(null, [index]));
 }
 MethodGenerator.prototype.visitBinaryExpression = function(node) {
   var $0;
   var kind = node.op.kind;
   if ($notnull_bool(kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var code = ('' + x.code + ' ' + node.op + ' ' + y.code + '');
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
-      var value = $notnull_bool((kind == 35/*TokenKind.AND*/)) ? x.get$actualValue() && y.get$actualValue() : x.get$actualValue() || y.get$actualValue();
+      var value = $notnull_bool((kind == 35/*TokenKind.AND*/)) ? $notnull_bool(x.get$actualValue() && y.get$actualValue()) : $notnull_bool(x.get$actualValue() || y.get$actualValue());
       return EvaluatedValue.EvaluatedValue$factory((($0 = x.type) && $0.is$lang_Type()), value, ('' + value + ''), node.span);
     }
-    return new Value(null, code, node.span, false, true, false);
+    var ret = new Value(lang_Type.union((($0 = x.type) && $0.is$lang_Type()), (($0 = y.type) && $0.is$lang_Type())), code, node.span, true);
+    return ret.convertToNonNullBool(this, node);
   }
   else if ($notnull_bool(kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
       var value = $notnull_bool(kind == 50/*TokenKind.EQ_STRICT*/) ? $eq(x.get$actualValue(), y.get$actualValue()) : $ne(x.get$actualValue(), y.get$actualValue());
       return EvaluatedValue.EvaluatedValue$factory(world.boolType, value, ("" + value + ""), node.span);
     }
     if ($notnull_bool(x.code == 'null' || y.code == 'null')) {
       var op = node.op.toString().substring(0, 2);
-      return new Value(null, ('' + x.code + ' ' + op + ' ' + y.code + ''), node.span, false, true, false);
+      return new Value(world.boolType, ('' + x.code + ' ' + op + ' ' + y.code + ''), node.span, true);
     }
     else {
-      return new Value(null, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), node.span, false, true, false);
+      return new Value(world.boolType, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), node.span, true);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
   if ($notnull_bool(assignKind == -1)) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var name = TokenKind.binaryMethodName(node.op.kind);
     if ($notnull_bool(node.op.kind == 49/*TokenKind.NE*/)) {
       name = '\$ne';
     }
@@ skipping 65 matching lines @@
         return members._set$4(this, position, x, y);
       }
       else {
         x = members._get$3(this, position, x);
       }
     }
   }
   y = y.convertTo(this, (($0 = x.type) && $0.is$lang_Type()), yn, false);
   if ($notnull_bool(kind == 0)) {
     x = captureOriginal((x && x.is$Value()));
-    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, false, true, false);
+    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
   }
-  else if ($notnull_bool(x.type.get$isNum() && y.type.get$isNum() && (kind != 46/*TokenKind.TRUNCDIV*/))) {
+  else if ($notnull_bool(x.type.get$isNum() && y.type.get$isNum()) && (kind != 46/*TokenKind.TRUNCDIV*/)) {
     x = captureOriginal((x && x.is$Value()));
     var op = TokenKind.kindToString(kind);
-    return new Value(y.type, ('' + x.code + ' ' + op + '= ' + y.code + ''), position.span, false, true, false);
+    return new Value(y.type, ('' + x.code + ' ' + op + '= ' + y.code + ''), position.span, true);
   }
   else {
     var right = x;
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, false, true, false);
+    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
   }
 }
 MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
   if ($notnull_bool(kind != 0)) {
     tmptarget = this.getTemp((target && target.is$Value()));
@@ skipping 23 matching lines @@
   return ret;
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var $0;
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       if ($notnull_bool(value.type.get$isNum())) {
-        return new Value(value.type, ('' + node.op + '' + value.code + ''), node.span, false, true, false);
+        return new Value(value.type, ('' + node.op + '' + value.code + ''), node.span, true);
       }
       else {
         var kind = ($notnull_bool(16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
         var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
         return this._visitAssign($assert_num(kind), node.self, (operand && operand.is$lang_Expression()), node, to$call$1(null));
       }
 
     case 19/*TokenKind.NOT*/:
 
       if ($notnull_bool(value.type.get$isBool() && value.get$isConst())) {
         var newVal = !$notnull_bool(value.get$actualValue());
         return EvaluatedValue.EvaluatedValue$factory((($0 = value.type) && $0.is$lang_Type()), newVal, ('' + newVal + ''), node.span);
       }
       else {
         var newVal = value.convertToNonNullBool(this, node);
-        return new Value(world.boolType, ('!' + newVal.code + ''), node.span, false, true, false);
+        return new Value(world.boolType, ('!' + newVal.code + ''), node.span, true);
       }
 
     case 42/*TokenKind.ADD*/:
 
       return value.convertTo(this, world.numType, node, false);
 
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
       if ($notnull_bool(node.op.kind == 18/*TokenKind.BIT_NOT*/)) {
@@ skipping 10 matching lines @@
     default:
 
       world.internalError(('unimplemented: ' + node.op + ''), node.span);
 
   }
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
   if ($notnull_bool(value.type.get$isNum())) {
-    return new Value(value.type, ('' + value.code + '' + node.op + ''), node.span, false, true, false);
+    return new Value(value.type, ('' + value.code + '' + node.op + ''), node.span, true);
   }
   var kind = $notnull_bool((16/*TokenKind.INCR*/ == node.op.kind)) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
   var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
   var tmpleft = null, left = null;
   var ret = this._visitAssign($assert_num(kind), node.body, (operand && operand.is$lang_Expression()), node, (function (l) {
     if ($notnull_bool(isVoid)) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp((l && l.is$Value()));
       return $this.assignTemp((tmpleft && tmpleft.is$Value()), (left && left.is$Value()));
     }
   })
   );
   if ($notnull_bool($ne(tmpleft, null))) {
-    ret = new Value(ret.type, ("(" + ret.code + ", " + tmpleft.code + ")"), node.span, false, true, false);
+    ret = new Value(ret.type, ("(" + ret.code + ", " + tmpleft.code + ")"), node.span, true);
   }
   if ($notnull_bool($ne(tmpleft, left))) {
     this.freeTemp((tmpleft && tmpleft.is$Value()));
   }
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var $0;
   var typeRef = node.type;
   var constructorName = '';
   if ($notnull_bool(node.name != null)) {
     constructorName = node.name.name;
   }
-  if ($notnull_bool($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference) && typeRef.names != null)) {
+  if ($notnull_bool($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference)) && typeRef.names != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.names);
     constructorName = names.removeLast().get$name();
     if ($notnull_bool(names.length == 0)) names = null;
     typeRef = new NameTypeReference(typeRef.isFinal, typeRef.get$name(), names, typeRef.get$span());
   }
   var type = this.method.resolveType(typeRef, true);
   if ($notnull_bool(type.get$isTop())) {
     type = type.get$library().findTypeByName($assert_String(constructorName));
     constructorName = '';
   }
@@ skipping 36 matching lines @@
       else {
         argsCode.add(arg.get$canonicalCode());
       }
     }
     else {
       argsCode.add(arg.code);
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed();
   var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
-  var value = new Value(world.listType, code, node.span, false, true, false);
+  var value = new Value(world.listType, code, node.span, true);
   if ($notnull_bool(node.isConst)) {
     var immutableList = world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor('from');
     var result = immutableListCtor.invoke$4(this, node, null, new Arguments(null, [value]));
     value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), result.code, node.span), (argValues && argValues.is$List$Value()));
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   var $0;
@@ skipping 21 matching lines @@
     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)) {
     var immutableMap = world.get$coreimpl().types.$index('ImmutableMap');
     var immutableMapCtor = immutableMap.getConstructor('');
-    var argsValue = new Value(world.listType, argList, node.span, false, true, false);
+    var argsValue = new Value(world.listType, argList, node.span, true);
     var result = immutableMapCtor.invoke$4(this, node, null, new Arguments(null, [argsValue]));
     var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, result.code, node.span);
     return world.gen.globalForConst(value, (argValues && argValues.is$List$Value()));
   }
-  return new Value(mapImplType, code, node.span, false, true, false);
+  return new Value(mapImplType, code, node.span, true);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var $0;
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ('' + test.code + ' ? ' + trueBranch.code + ' : ' + falseBranch.code + '');
-  return new Value(lang_Type.union((($0 = trueBranch.type) && $0.is$lang_Type()), (($0 = falseBranch.type) && $0.is$lang_Type())), code, node.span, false, true, false);
+  return new Value(lang_Type.union((($0 = trueBranch.type) && $0.is$lang_Type()), (($0 = falseBranch.type) && $0.is$lang_Type())), code, node.span, true);
 }
 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.get$canonicalCode() + ')'), node.span);
   }
-  return new Value(body.type, ('(' + body.code + ')'), node.span, false, true, false);
+  return new Value(body.type, ('(' + body.code + ')'), node.span, true);
 }
 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);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._makeThisOrType(node.span).get_(this, name, node);
 }
 MethodGenerator.prototype._makeMissingValue = function(name) {
-  return new Value(null, ('' + name + '()/*NotFound*/'), null, false, true, false);
+  return new Value(world.varType, ('' + name + '()/*NotFound*/'), null, true);
 }
 MethodGenerator.prototype._makeThisOrType = function(span) {
   var $0;
   return new BareValue(this, (($0 = this._getOutermostMethod()) && $0.is$MethodGenerator()), span);
 }
 MethodGenerator.prototype.visitThisExpression = function(node) {
   return this._makeThisValue(node);
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
-  return EvaluatedValue.EvaluatedValue$factory(null, null, 'null', null);
+  return EvaluatedValue.EvaluatedValue$factory(world.varType, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2078, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2073, 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 + ')');
       }
       items.add(code);
     }
-    return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, false, true, false);
+    return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if ($notnull_bool(type.get$isString())) {
     if ($notnull_bool(text.startsWith('@'))) {
       text = MethodGenerator._escapeString(parseStringLiteral($assert_String(text)));
       text = ('"' + text + '"');
     }
     else if ($notnull_bool(isMultilineString($assert_String(text)))) {
       text = parseStringLiteral($assert_String(text));
       text = text.replaceAll('\n', '\\n');
@@ skipping 15 matching lines @@
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
   // Initializers done
 }
 Arguments.prototype.is$Arguments = function(){return this;};
 Arguments.Arguments$bare$factory = function(arity) {
   var values = [];
   for (var i = 0;
    $notnull_bool(i < arity); i++) {
-    values.add(new Value(world.varType, ('\$' + i + ''), null, false, false, false));
+    values.add(new Value(world.varType, ('\$' + i + ''), null, false));
   }
   return new Arguments(null, values);
 }
 Arguments.get$EMPTY = function() {
   if ($notnull_bool(Arguments._empty == null)) {
     Arguments._empty = new Arguments(null, []);
   }
   return Arguments._empty;
 }
 Arguments.prototype.get$nameCount = function() {
@@ skipping 59 matching lines @@
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     names.add(this.getName(i));
   }
   return (names && names.is$List$String());
 }
 Arguments.prototype.toCallStubArgs = function() {
   var result = [];
   for (var i = 0;
    $notnull_bool(i < this.get$bareCount()); i++) {
-    result.add(new Value(world.varType, ('\$' + i + ''), null, false, false, false));
+    result.add(new Value(world.varType, ('\$' + i + ''), null, false));
   }
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     var name = this.getName(i);
     if ($notnull_bool(name == null)) name = ('\$' + i + '');
-    result.add(new Value(world.varType, name, null, false, false, false));
+    result.add(new Value(world.varType, name, null, false));
   }
   return new Arguments(this.nodes, result);
 }
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix) {
   this.library = library;
   this.prefix = prefix;
   // Initializers done
 }
 LibraryImport.prototype.get$library = function() { return this.library; };
@@ skipping 47 matching lines @@
 Library.prototype._findMembers = function(name) {
   var $0;
   if ($notnull_bool(name.startsWith('_'))) {
     return (($0 = this._privateMembers.$index(name)) && $0.is$MemberSet());
   }
   else {
     return (($0 = world._members.$index(name)) && $0.is$MemberSet());
   }
 }
 Library.prototype._addMember = function(member) {
-  var $0;
   if ($notnull_bool(member.get$isPrivate())) {
     if ($notnull_bool(member.get$isStatic())) {
       if ($notnull_bool(member.declaringType.get$isTop())) {
         world._addTopName(member);
       }
       return;
     }
     var mset = this._privateMembers.$index(member.name);
     if ($notnull_bool(mset == null)) {
       var $list = world.libraries.getValues();
@@ skipping 102 matching lines @@
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   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);
     if ($notnull_bool(index > 0)) {
       this.name = this.name.substring(0, index);
     }
@@ skipping 36 matching lines @@
   })
   ))) {
     world.error(('file "' + filename + '" has already been sourced'), span);
     return;
   }
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 _LibraryVisitor.prototype.addSource = function(source) {
   var $this = this; // closure support
-  var $0;
   if ($notnull_bool(this.library.sources.some((function (s) {
     return s.filename == source.filename;
   })
   ))) {
     world.error(('duplicate source file "' + source.filename + '"'));
     return;
   }
   this.library.sources.add(source);
   var parser = new lang_Parser(source, options.dietParse, false, false, 0);
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit($this);
   })
   );
-  $assert(this.sources.length == 0 || this.isTop, "sources.length == 0 || isTop", "library.dart", 293, 12);
+  $assert($notnull_bool(this.sources.length == 0 || this.isTop), "sources.length == 0 || isTop", "library.dart", 293, 12);
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource((source0 && source0.is$SourceFile()));
   }
 }
 _LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
   if ($notnull_bool(!$notnull_bool(this.isTop))) {
     world.error('directives not allowed in sourced file', node.span);
     return;
   }
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
       if ($notnull_bool(this.library.name == null)) {
         this.library.name = $assert_String(name);
         if ($notnull_bool($eq(name, 'node') || $eq(name, 'dom'))) {
           this.library.topType.isNativeType = true;
         }
-        if ($notnull_bool(this.seenImport || this.seenSource || this.seenResource)) {
+        if ($notnull_bool(this.seenImport || this.seenSource) || this.seenResource) {
           world.error('#library must be first directive in file', node.span);
         }
       }
       else {
         world.error('already specified library name', node.span);
       }
       break;
 
     case "import":
 
       this.seenImport = true;
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
-      if ($notnull_bool(node.arguments.length > 2 || node.arguments.length == 2 && prefix == null)) {
+      if ($notnull_bool(node.arguments.length > 2 || $notnull_bool(node.arguments.length == 2 && prefix == null))) {
         world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.length + ''), node.span);
       }
       else if ($notnull_bool($ne(prefix, null) && prefix.indexOf('.', 0) >= 0)) {
         world.error('library prefix canot contain "."', node.span);
       }
       else if ($notnull_bool(this.seenSource || this.seenResource)) {
         world.error('#imports must come before any #source or #resource', node.span);
       }
       if ($notnull_bool($eq(prefix, ''))) prefix = null;
       var filename = this.library.makeFullPath($assert_String(name));
@@ skipping 45 matching lines @@
   if ($notnull_bool(node.arguments.length < 1)) {
     world.error(('expected at least one argument but found ' + node.arguments.length + ''), node.span);
   }
   var arg = node.arguments.$index(0);
   if ($notnull_bool(arg.label != null)) {
     world.error('label not allowed for directive', node.span);
   }
   return this._parseStringArgument((arg && arg.is$ArgumentNode()));
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
-  var $0;
   var args = node.arguments.filter((function (a) {
-    return a.label != null && a.label.name == argName;
+    return $notnull_bool(a.label != null && a.label.name == argName);
   })
   );
   if ($notnull_bool(args.length == 0)) {
     return null;
   }
   if ($notnull_bool(args.length > 1)) {
     world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
   }
   for (var $i = args.iterator(); $i.hasNext(); ) {
     var arg = $i.next();
@@ skipping 75 matching lines @@
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   ret.isInitializer = this.isInitializer;
   return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
-  return $assert_bool(this.definition != null && this.definition.value != null);
+  return $notnull_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 55 matching lines @@
 Member.prototype.set$initDelegate = function(ctor) {
   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 $assert_bool(this.get$canGet() && new Value(this.get$returnType(), null, null, false, true, false).canInvoke(context, '\$call', args));
+  return $notnull_bool(this.get$canGet() && new Value(this.get$returnType(), null, null, true).canInvoke(context, '\$call', args));
 }
 Member.prototype.invoke = function(context, node, target, args, isDynamic) {
   var newTarget = this._get(context, node, target, isDynamic);
   return newTarget.invoke(context, '\$call', node, args, isDynamic);
 }
 Member.prototype.override = function(other) {
   if ($notnull_bool(this.get$isStatic())) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
@@ skipping 55 matching lines @@
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
 TypeMember.prototype.resolve = function(inType) {
 
 }
 TypeMember.prototype._get = function(context, node, target, isDynamic) {
-  return new Value(this.type, this.type.get$jsname(), node.span, false, false, true);
+  var ret = new Value(this.type, this.type.get$jsname(), node.span, false);
+  ret.isType = true;
+  return (ret && ret.is$Value());
 }
 TypeMember.prototype._set = function(context, node, target, value, isDynamic) {
   world.error('can not set type', this.type.definition.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', this.type.definition.span);
 }
 TypeMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
@@ skipping 83 matching lines @@
       }
       else {
         world.error(('' + mod + ' modifier not allowed on field'), mod.get$span());
       }
     }
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(this.isStatic && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.type.span);
   }
-  if ($notnull_bool(this.isStatic && this.isFinal && this.value == null)) {
+  if ($notnull_bool(this.isStatic && this.isFinal) && this.value == null) {
     world.error('static final field is missing initializer', this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   var $0;
   if ($notnull_bool(this.value == null)) return null;
   if ($notnull_bool(this._computedValue == null)) {
     if ($notnull_bool(this._computing)) {
       world.error('circular reference', this.value.span);
@@ skipping 23 matching lines @@
   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 && cv.is$Value());
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
-      return new Value(this.type, ('' + this.get$jsname() + ''), node.span, false, true, false);
+      return new Value(this.type, ('' + this.get$jsname() + ''), node.span, true);
     }
     else {
-      return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), node.span, false, true, false);
+      return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), node.span, true);
     }
   }
   else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
     var constTarget = $notnull_bool((target instanceof GlobalValue)) ? target.get$dynamic().exp : target;
     if ($notnull_bool((constTarget instanceof ConstObjectValue))) {
       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, ('' + constTarget.get$actualValue().length + ''), node.span, true);
     }
   }
-  return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, false, true, false);
+  return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
-  return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), node.span, false, true, false);
+  return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), node.span, true);
 }
 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 **************
@@ skipping 186 matching lines @@
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
   var type = this.baseMember.resolveType(node, isRequired);
   return type.resolveTypeParams(this.declaringType);
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
-  return new Value(this.returnType, ret.code, node.span, false, true, false);
+  return new Value(this.returnType, ret.code, node.span, true);
 }
 ConcreteMember.prototype._set = function(context, node, target, value, isDynamic) {
   var ret = this.baseMember._set(context, node, target, value, isDynamic);
-  return new Value(this.returnType, ret.code, node.span, false, true, false);
+  return new Value(this.returnType, ret.code, node.span, true);
 }
 ConcreteMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var ret = this.baseMember.invoke(context, node, target, args, isDynamic);
   var code = ret.code;
   if ($notnull_bool(this.get$isConstructor())) {
     code = code.replaceFirst(this.declaringType.get$genericType().get$jsname(), this.declaringType.get$jsname());
   }
   this.declaringType.genMethod(this);
-  return new Value(this.returnType, code, node.span, false, true, false);
+  return new Value(this.returnType, code, node.span, true);
 }
 ConcreteMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 ConcreteMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 }
 ;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
@@ skipping 122 matching lines @@
   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);
+    return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), node.span, true);
   }
   this._providePropertySyntax = true;
-  return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), node.span, false, true, false);
+  return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), node.span, true);
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if ($notnull_bool(!$notnull_bool(args.get$hasNames()))) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
    $notnull_bool(i < this.parameters.length); i++) {
     var p = args.getIndexOfName($assert_String(this.parameters.$index(i).get$name()));
     if ($notnull_bool(p >= 0 && args.values.$index(p).needsTemp)) {
       if ($notnull_bool(lastParameter != null && lastParameter > $assert_num(p))) {
         return false;
@@ skipping 51 matching lines @@
     this.resolve(this.declaringType);
   }
   this.declaringType.genMethod(this);
   if ($notnull_bool(this.isStatic || this.isFactory)) {
     this.declaringType.markUsed();
   }
   if ($notnull_bool(!$notnull_bool(this.namesInOrder(args)))) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
-  if ($notnull_bool(target != null && (this.get$isConstructor() || target.isSuper))) {
+  if ($notnull_bool(target != null && ($notnull_bool(this.get$isConstructor() || target.isSuper)))) {
     argsCode.add('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
    $notnull_bool(i < bareCount); i++) {
     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));
     }
@@ skipping 45 matching lines @@
       }
       world.internalError(('wrong named arguments calling ' + this.name + ''), node.span);
     }
     Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
   }
   var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
   if ($notnull_bool(this.get$isConstructor())) {
     return this._invokeConstructor(context, node, target, args, argsString);
   }
   if ($notnull_bool(target != null && target.isSuper)) {
-    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, false, true, false);
+    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.name.startsWith('\$'))) {
     return this._invokeBuiltin(context, node, target, args, argsCode);
   }
   if ($notnull_bool(this.isFactory)) {
-    return new Value(this.returnType, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, false, true, false);
+    return new Value(this.returnType, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), node.span, true);
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
-      return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), $notnull_bool(node != null) ? node.span : node, false, true, false);
+      return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), $notnull_bool(node != null) ? node.span : node, true);
     }
-    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, false, true, false);
+    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
     if ($notnull_bool((target instanceof GlobalValue))) {
       target = target.get$dynamic().exp;
     }
     if ($notnull_bool(this.name == 'get\$length')) {
       if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
         code = ('' + target.get$dynamic().values.length + '');
       }
     }
     else if ($notnull_bool(this.name == 'isEmpty')) {
       if ($notnull_bool((target instanceof ConstListValue) || (target instanceof ConstMapValue))) {
         code = ('' + target.get$dynamic().values.isEmpty() + '');
       }
     }
   }
   if ($notnull_bool(this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), world.get$dom()))) {
     world.gen.corejs.useTypeNameOf = true;
   }
-  return new Value(this.returnType, code, node.span, false, true, false);
+  return new Value(this.returnType, code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
   if ($notnull_bool(target != null)) {
     var code = $notnull_bool((this.get$constructorName() != '')) ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
-    return new Value(this.declaringType, code, node.span, false, true, false);
+    return new Value(this.declaringType, code, node.span, true);
   }
   else {
     var code = $notnull_bool((this.get$constructorName() != '')) ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
-    if ($notnull_bool(this.isConst && (node instanceof lang_NewExpression) && node.get$dynamic().get$isConst())) {
+    if ($notnull_bool(this.isConst && (node instanceof lang_NewExpression)) && node.get$dynamic().get$isConst()) {
       return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
-      return new Value(this.declaringType, code, node.span, false, true, false);
+      return new Value(this.declaringType, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
   var fields = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
    $notnull_bool(i < this.parameters.length); i++) {
     var param = this.parameters.$index(i);
     if ($notnull_bool(param.isInitializer)) {
@@ skipping 53 matching lines @@
         var fname = x.name.name;
         var val = this.generator.visitValue(assign.y);
         fields.$setindex(fname, val);
       }
     }
     this.generator._popBlock();
   }
   var $list = this.declaringType.get$members().getValues();
   for (var $i = this.declaringType.get$members().getValues().iterator(); $i.hasNext(); ) {
     var f = $i.next();
-    if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic()) && $ne(f.get$value(), null) && !$notnull_bool(fields.containsKey(f.get$name())))) {
+    if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic())) && $ne(f.get$value(), null) && !$notnull_bool(fields.containsKey(f.get$name()))) {
       fields.$setindex(f.get$name(), f.computeValue());
     }
   }
   return world.gen.globalForConst(ConstObjectValue.ConstObjectValue$factory(this.declaringType, fields, code, node.span), args.values);
 }
 MethodMember.prototype._invokeBuiltin = function(context, node, target, args, argsCode) {
-  var allConst = target.get$isConst() && args.values.every((function (arg) {
+  var allConst = $notnull_bool(target.get$isConst() && args.values.every((function (arg) {
     return arg.get$isConst();
   })
-  );
+  ));
   if ($notnull_bool(this.declaringType.get$isNum())) {
     if ($notnull_bool(!$notnull_bool(allConst))) {
       var code;
       if ($notnull_bool(this.name == '\$negate')) {
         code = ('-' + target.code + '');
       }
       else if ($notnull_bool(this.name == '\$bit_not')) {
         code = ('~' + target.code + '');
       }
       else if ($notnull_bool(this.name == '\$truncdiv' || this.name == '\$mod')) {
         world.gen.corejs.useOperator(this.name);
         code = ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')');
       }
       else {
         var op = TokenKind.rawOperatorFromMethod(this.name);
         code = ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + '');
       }
-      return new Value(this.returnType, code, node.span, false, true, false);
+      return new Value(this.returnType, code, node.span, true);
     }
     else {
       var value;
       var val0, val1, ival0, ival1;
       val0 = $assert_num(target.get$dynamic().get$actualValue());
       ival0 = val0.toInt();
       if ($notnull_bool(args.values.length > 0)) {
         val1 = $assert_num(args.values.$index(0).get$dynamic().get$actualValue());
         ival1 = val1.toInt();
       }
@@ skipping 97 matching lines @@
 
           value = (ival0 >>> ival1).toDouble();
           break;
 
       }
       return EvaluatedValue.EvaluatedValue$factory(this.returnType, value, ("" + value + ""), node.span);
     }
   }
   else if ($notnull_bool(this.declaringType.get$isString())) {
     if ($notnull_bool(this.name == '\$index')) {
-      return new Value(this.declaringType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, false, true, false);
+      return new Value(this.declaringType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
     else if ($notnull_bool(this.name == '\$add')) {
       if ($notnull_bool(allConst)) {
         var val0 = target.get$dynamic().get$actualValue();
         val0 = val0.substring(1, val0.length - 1);
         var val1 = args.values.$index(0).get$dynamic().get$actualValue();
         if ($notnull_bool(args.values.$index(0).type.get$isString())) {
           val1 = val1.substring(1, val1.length - 1);
         }
         var value = ('' + val0 + '' + val1 + '');
         value = '"' + value.replaceAll('"', '\\"') + '"';
         return EvaluatedValue.EvaluatedValue$factory(world.stringType, value, $assert_String(value), node.span);
       }
       args.values.$index(0).invoke$4(context, 'toString', node, Arguments.get$EMPTY());
-      return new Value(this.declaringType, ('' + target.code + ' + ' + argsCode.$index(0) + ''), node.span, false, true, false);
+      return new Value(this.declaringType, ('' + target.code + ' + ' + argsCode.$index(0) + ''), node.span, true);
     }
   }
   else if ($notnull_bool(this.declaringType.get$isNativeType())) {
     if ($notnull_bool(this.name == '\$index')) {
-      return new Value(null, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, false, true, false);
+      return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
     else if ($notnull_bool(this.name == '\$setindex')) {
-      return new Value(null, ('' + target.code + '[' + argsCode.$index(0) + '] = ' + argsCode.$index(1) + ''), node.span, false, true, false);
+      return new Value(this.returnType, ('' + target.code + '[' + argsCode.$index(0) + '] = ' + argsCode.$index(1) + ''), node.span, true);
     }
   }
   if ($notnull_bool(this.name == '\$eq' || this.name == '\$ne')) {
     var op = $notnull_bool(this.name == '\$eq') ? '==' : '!=';
     if ($notnull_bool(allConst)) {
       var val0 = target.get$dynamic().get$actualValue();
       var val1 = args.values.$index(0).get$dynamic().get$actualValue();
       var newVal = $notnull_bool(this.name == '\$eq') ? $eq(val0, val1) : $ne(val0, val1);
       return EvaluatedValue.EvaluatedValue$factory(world.boolType, newVal, ("" + newVal + ""), node.span);
     }
     if ($notnull_bool($eq(argsCode.$index(0), 'null'))) {
-      return new Value(this.returnType, ('' + target.code + ' ' + op + ' null'), node.span, false, true, false);
+      return new Value(this.returnType, ('' + target.code + ' ' + op + ' null'), node.span, true);
     }
     else if ($notnull_bool(target.type.get$isNum() || target.type.get$isString())) {
-      return new Value(this.returnType, ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), node.span, false, true, false);
+      return new Value(this.returnType, ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), node.span, true);
     }
     world.gen.corejs.useOperator(this.name);
-    return new Value(this.returnType, ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), node.span, false, true, false);
+    return new Value(this.returnType, ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), node.span, true);
   }
   if ($notnull_bool(this.name == '\$call')) {
     this.declaringType.markUsed();
-    return new Value(this.returnType, ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), node.span, false, true, false);
+    return new Value(this.returnType, ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), node.span, true);
   }
   if ($notnull_bool(this.name == '\$index')) {
     world.gen.corejs.useIndex = true;
   }
   else if ($notnull_bool(this.name == '\$setindex')) {
     world.gen.corejs.useSetIndex = true;
   }
   var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
-  return new Value(this.returnType, ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, false, true, false);
+  return new Value(this.returnType, ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
 }
 MethodMember.prototype.resolve = function(inType) {
   this.isStatic = inType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !$notnull_bool(this.declaringType.get$isClass());
   if ($notnull_bool(this.definition.modifiers != null)) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
@@ skipping 27 matching lines @@
         this.isAbstract = true;
       }
       else {
         world.error(('' + mod + ' modifier not allowed on method'), mod.get$span());
       }
     }
   }
   if ($notnull_bool(this.isFactory)) {
     this.isStatic = true;
   }
-  if ($notnull_bool(this.name.startsWith('\$') && !$notnull_bool(this.name.startsWith('\$call')) && this.isStatic)) {
+  if ($notnull_bool(this.name.startsWith('\$') && !$notnull_bool(this.name.startsWith('\$call'))) && this.isStatic) {
     world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if ($notnull_bool(this.isAbstract)) {
     if ($notnull_bool(this.definition.body != null && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition))) {
       world.error('abstract method can not have a body', this.get$span());
     }
     if ($notnull_bool(this.isStatic && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition))) {
       world.error('static method can not be abstract', this.get$span());
     }
   }
@@ skipping 52 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 $assert_bool(this.members.length == 1 && this.members.$index(0).get$isStatic());
+  return $notnull_bool(this.members.length == 1 && this.members.$index(0).get$isStatic());
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if ($notnull_bool(!$notnull_bool(target.type.get$isVar()))) {
     world.warning(('could not find applicable ' + action + ' for "' + this.name + '"'), node.span);
   }
-  return new Value(null, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), node.span, false, true, false);
+  return new Value(world.varType, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), node.span, true);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if ($notnull_bool(this._treatAsField == null)) {
     this._treatAsField = true;
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(member.get$requiresFieldSyntax())) {
         this._treatAsField = true;
         break;
       }
       if ($notnull_bool(member.get$prefersPropertySyntax())) {
         this._treatAsField = false;
       }
     }
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(this._treatAsField)) {
         member.provideFieldSyntax();
       }
       else {
         member.providePropertySyntax();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
-  var $0;
   if ($notnull_bool(this.members.length == 1)) {
     return this.members.$index(0)._get(context, node, target, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.get$canGet();
   })
   );
   if ($notnull_bool(targets.length == 1)) {
     return targets.$index(0)._get(context, node, target, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
     var value = member._get(context, node, target, true);
     returnValue = this._tryUnion(returnValue, value, node);
   }
   if ($notnull_bool(returnValue == null)) {
     return this._makeError(node, target, 'getter');
   }
   if ($notnull_bool(returnValue.code == null)) {
     if ($notnull_bool(this.get$treatAsField())) {
-      return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), node.span, false, true, false);
+      return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), node.span, true);
     }
     else {
-      return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), node.span, false, true, false);
+      return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
-  var $0;
   if ($notnull_bool(this.members.length == 1)) {
     return this.members.$index(0)._set(context, node, target, value, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
   if ($notnull_bool(targets.length == 1)) {
     return targets.$index(0)._set(context, node, target, value, isDynamic);
   }
   var returnValue = null;
   for (var $i = targets.iterator(); $i.hasNext(); ) {
     var member = $i.next();
     var res = member._set(context, node, target, value, true);
     returnValue = this._tryUnion(returnValue, res, node);
   }
   if ($notnull_bool(returnValue == null)) {
     return this._makeError(node, target, 'setter');
   }
   if ($notnull_bool(returnValue.code == null)) {
     if ($notnull_bool(this.get$treatAsField())) {
-      return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), node.span, false, true, false);
+      return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), node.span, true);
     }
     else {
-      return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, false, true, false);
+      return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
-  var $0;
   if ($notnull_bool(this.members.length == 1)) {
     return this.members.$index(0).invoke(context, node, target, args, isDynamic);
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke(context, args);
   })
   );
   if ($notnull_bool(targets.length == 1)) {
     return targets.$index(0).invoke(context, node, target, args, isDynamic);
   }
@@ skipping 23 matching lines @@
   if ($notnull_bool(x == null)) return y;
   var type = lang_Type.union(x.type, y.type);
   if ($notnull_bool(x.code == y.code)) {
     if ($notnull_bool($eq(type, x.type))) {
       return x;
     }
     else if ($notnull_bool(x.get$isConst() || y.get$isConst())) {
       world.internalError("unexpected: union of const values ");
     }
     else {
-      return new Value(type, x.code, node.span, x.isSuper && y.isSuper, x.needsTemp || y.needsTemp, x.isType && y.isType);
+      var ret = new Value(type, x.code, node.span, true);
+      ret.isSuper = $notnull_bool(x.isSuper && y.isSuper);
+      ret.needsTemp = $notnull_bool(x.needsTemp || y.needsTemp);
+      ret.isType = $notnull_bool(x.isType && y.isType);
+      return (ret && ret.is$Value());
     }
   }
   else {
-    return new Value(type, null, node.span, false, true, false);
+    return new Value(type, null, node.span, true);
   }
 }
 MemberSet.prototype.getVarMember = function(context, node, args) {
   if ($notnull_bool(world.objectType.varStubs == null)) {
     world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = world.objectType.varStubs.$index(stubName);
   if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
@@ skipping 244 matching lines @@
       else {
         return this._finishToken(63/*TokenKind.WHITESPACE*/);
       }
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
 TokenizerBase.prototype.finishHashBang = function() {
   while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0 || ch == 10 || ch == 13)) {
+    if ($notnull_bool(ch == 0 || ch == 10) || ch == 13) {
       return this._finishToken(13/*TokenKind.HASHBANG*/);
     }
   }
 }
 TokenizerBase.prototype.finishSingleLineComment = function() {
   while ($notnull_bool(true)) {
     var ch = this._nextChar();
-    if ($notnull_bool(ch == 0 || ch == 10 || ch == 13)) {
+    if ($notnull_bool(ch == 0 || ch == 10) || ch == 13) {
       if ($notnull_bool(this._skipWhitespace)) {
         return this.next();
       }
       else {
         return this._finishToken(64/*TokenKind.COMMENT*/);
       }
     }
   }
 }
 TokenizerBase.prototype.finishMultiLineComment = function() {
@@ skipping 149 matching lines @@
     }
   }
 }
 TokenizerBase.prototype.finishMultilineRawString = function(quote) {
   while ($notnull_bool(true)) {
     var ch = this._nextChar();
     if ($notnull_bool(ch == 0)) {
       var kind = $notnull_bool(quote == 34) ? 68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/ : 69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/;
       return this._finishToken(kind);
     }
-    else if ($notnull_bool(ch == quote && this._maybeEatChar(quote) && this._maybeEatChar(quote))) {
+    else if ($notnull_bool(ch == quote && this._maybeEatChar(quote)) && this._maybeEatChar(quote)) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
   }
 }
 TokenizerBase.prototype.finishStringBody = function(quote) {
   while ($notnull_bool(true)) {
     var ch = this._nextChar();
     if ($notnull_bool(ch == quote)) {
       return this._finishToken(58/*TokenKind.STRING*/);
     }
     else if ($notnull_bool(ch == 36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, false);
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
     else if ($notnull_bool(ch == 0)) {
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
     else if ($notnull_bool(ch == 92)) {
       if ($notnull_bool(!$notnull_bool(this.eatEscapeSequence()))) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
-      return $assert_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit());
+      return $notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit());
 
     case 117:
 
       if ($notnull_bool(this._maybeEatChar(123))) {
         var start = this._lang_index;
         this.eatHexDigits();
         var chars = this._lang_index - start;
-        if ($notnull_bool(chars > 0 && chars <= 6 && this._maybeEatChar(125))) {
+        if ($notnull_bool(chars > 0 && chars <= 6) && this._maybeEatChar(125)) {
           hex = this._text.substring(start, start + chars);
           break;
         }
         else {
           return false;
         }
       }
       else {
-        if ($notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit() && this.maybeEatHexDigit())) {
+        if ($notnull_bool(this.maybeEatHexDigit() && this.maybeEatHexDigit()) && this.maybeEatHexDigit() && this.maybeEatHexDigit()) {
           hex = this._text.substring(this._lang_index - 4, this._lang_index);
           break;
         }
         else {
           return false;
         }
       }
 
     default:
 
       return true;
 
   }
   var n = lang_Parser.parseHex(hex);
-  return $assert_bool(n < 0xD800 || n > 0xDFFF && n <= 0x10FFFF);
+  return $notnull_bool(n < 0xD800 || $notnull_bool(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 394 matching lines @@
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 121)) return 111/*TokenKind.TRY*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 118)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 114)) return 112/*TokenKind.VAR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 4:
 
       if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101)) return 89/*TokenKind.CASE*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101) return 89/*TokenKind.CASE*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 101)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101)) return 95/*TokenKind.ELSE*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 108 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101) return 95/*TokenKind.ELSE*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 110)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 108)) return 104/*TokenKind.NULL*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 108) && this._text.charCodeAt(i0 + 3) == 108) return 104/*TokenKind.NULL*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104)) {
           if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 115)) return 108/*TokenKind.THIS*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114)) {
           if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 101)) return 110/*TokenKind.TRUE*/;
         }
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 118)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 100)) return 113/*TokenKind.VOID*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 105) && this._text.charCodeAt(i0 + 3) == 100) return 113/*TokenKind.VOID*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 5:
 
       if ($notnull_bool(this._text.charCodeAt(i0) == 98)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107)) return 88/*TokenKind.BREAK*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 114 && this._text.charCodeAt(i0 + 2) == 101) && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 107) return 88/*TokenKind.BREAK*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99 && this._text.charCodeAt(i0 + 4) == 104)) return 90/*TokenKind.CATCH*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 99) && this._text.charCodeAt(i0 + 4) == 104) return 90/*TokenKind.CATCH*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 108)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 115)) return 73/*TokenKind.CLASS*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 115) return 73/*TokenKind.CLASS*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 116)) return 91/*TokenKind.CONST*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 116) return 91/*TokenKind.CONST*/;
         }
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 102)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115 && this._text.charCodeAt(i0 + 4) == 101)) return 96/*TokenKind.FALSE*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 108 && this._text.charCodeAt(i0 + 3) == 115) && this._text.charCodeAt(i0 + 4) == 101) return 96/*TokenKind.FALSE*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108)) return 97/*TokenKind.FINAL*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 108) return 97/*TokenKind.FINAL*/;
         }
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 115)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114)) return 106/*TokenKind.SUPER*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 117 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114) return 106/*TokenKind.SUPER*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119)) return 109/*TokenKind.THROW*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 114) && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 119) return 109/*TokenKind.THROW*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 119)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101)) return 114/*TokenKind.WHILE*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 104 && this._text.charCodeAt(i0 + 2) == 105) && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101) return 114/*TokenKind.WHILE*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 6:
 
       if ($notnull_bool(this._text.charCodeAt(i0) == 97)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116)) return 72/*TokenKind.ASSERT*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 115 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 72/*TokenKind.ASSERT*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 105)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116)) return 78/*TokenKind.IMPORT*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 111 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 116) return 78/*TokenKind.IMPORT*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 110)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105 && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101)) return 81/*TokenKind.NATIVE*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 105) && this._text.charCodeAt(i0 + 4) == 118 && this._text.charCodeAt(i0 + 5) == 101) return 81/*TokenKind.NATIVE*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101)) return 82/*TokenKind.NEGATE*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 103 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 116 && this._text.charCodeAt(i0 + 5) == 101) return 82/*TokenKind.NEGATE*/;
         }
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 114)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110)) return 105/*TokenKind.RETURN*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 116) && this._text.charCodeAt(i0 + 3) == 117 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 110) return 105/*TokenKind.RETURN*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 115)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101)) return 85/*TokenKind.SOURCE*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 117 && this._text.charCodeAt(i0 + 3) == 114) && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 101) return 85/*TokenKind.SOURCE*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 116)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99)) return 86/*TokenKind.STATIC*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 97 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 99) return 86/*TokenKind.STATIC*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 119)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104)) return 107/*TokenKind.SWITCH*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 105 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 99 && this._text.charCodeAt(i0 + 5) == 104) return 107/*TokenKind.SWITCH*/;
         }
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 7:
 
       if ($notnull_bool(this._text.charCodeAt(i0) == 100)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116)) return 93/*TokenKind.DEFAULT*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 101 && this._text.charCodeAt(i0 + 2) == 102) && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 117 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 116) return 93/*TokenKind.DEFAULT*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 101)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115)) return 74/*TokenKind.EXTENDS*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 120 && this._text.charCodeAt(i0 + 2) == 116) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 110 && this._text.charCodeAt(i0 + 5) == 100 && this._text.charCodeAt(i0 + 6) == 115) return 74/*TokenKind.EXTENDS*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 102)) {
         if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 97)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121)) return 75/*TokenKind.FACTORY*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 99 && this._text.charCodeAt(i0 + 3) == 116) && this._text.charCodeAt(i0 + 4) == 111 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 75/*TokenKind.FACTORY*/;
         }
         else if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105)) {
-          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97 && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121)) return 98/*TokenKind.FINALLY*/;
+          if ($notnull_bool(this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 97) && this._text.charCodeAt(i0 + 4) == 108 && this._text.charCodeAt(i0 + 5) == 108 && this._text.charCodeAt(i0 + 6) == 121) return 98/*TokenKind.FINALLY*/;
         }
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 108)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121)) return 80/*TokenKind.LIBRARY*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 105 && this._text.charCodeAt(i0 + 2) == 98) && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 114 && this._text.charCodeAt(i0 + 6) == 121) return 80/*TokenKind.LIBRARY*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 116)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102)) return 87/*TokenKind.TYPEDEF*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 121 && this._text.charCodeAt(i0 + 2) == 112) && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 100 && this._text.charCodeAt(i0 + 5) == 101 && this._text.charCodeAt(i0 + 6) == 102) return 87/*TokenKind.TYPEDEF*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 8:
 
       if ($notnull_bool(this._text.charCodeAt(i0) == 97)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116)) return 71/*TokenKind.ABSTRACT*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 98 && this._text.charCodeAt(i0 + 2) == 115) && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 97 && this._text.charCodeAt(i0 + 6) == 99 && this._text.charCodeAt(i0 + 7) == 116) return 71/*TokenKind.ABSTRACT*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 99)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110 && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101)) return 92/*TokenKind.CONTINUE*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 111 && this._text.charCodeAt(i0 + 2) == 110) && this._text.charCodeAt(i0 + 3) == 116 && this._text.charCodeAt(i0 + 4) == 105 && this._text.charCodeAt(i0 + 5) == 110 && this._text.charCodeAt(i0 + 6) == 117 && this._text.charCodeAt(i0 + 7) == 101) return 92/*TokenKind.CONTINUE*/;
       }
       else if ($notnull_bool(this._text.charCodeAt(i0) == 111)) {
-        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101 && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114)) return 83/*TokenKind.OPERATOR*/;
+        if ($notnull_bool(this._text.charCodeAt(i0 + 1) == 112 && this._text.charCodeAt(i0 + 2) == 101) && this._text.charCodeAt(i0 + 3) == 114 && this._text.charCodeAt(i0 + 4) == 97 && this._text.charCodeAt(i0 + 5) == 116 && this._text.charCodeAt(i0 + 6) == 111 && this._text.charCodeAt(i0 + 7) == 114) return 83/*TokenKind.OPERATOR*/;
       }
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 9:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110 && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101)) return 79/*TokenKind.INTERFACE*/;
+      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 110) && this._text.charCodeAt(i0 + 2) == 116 && this._text.charCodeAt(i0 + 3) == 101 && this._text.charCodeAt(i0 + 4) == 114 && this._text.charCodeAt(i0 + 5) == 102 && this._text.charCodeAt(i0 + 6) == 97 && this._text.charCodeAt(i0 + 7) == 99 && this._text.charCodeAt(i0 + 8) == 101) return 79/*TokenKind.INTERFACE*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     case 10:
 
-      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109 && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115)) return 77/*TokenKind.IMPLEMENTS*/;
+      if ($notnull_bool(this._text.charCodeAt(i0) == 105 && this._text.charCodeAt(i0 + 1) == 109) && this._text.charCodeAt(i0 + 2) == 112 && this._text.charCodeAt(i0 + 3) == 108 && this._text.charCodeAt(i0 + 4) == 101 && this._text.charCodeAt(i0 + 5) == 109 && this._text.charCodeAt(i0 + 6) == 101 && this._text.charCodeAt(i0 + 7) == 110 && this._text.charCodeAt(i0 + 8) == 116 && this._text.charCodeAt(i0 + 9) == 115) return 77/*TokenKind.IMPLEMENTS*/;
       return 70/*TokenKind.IDENTIFIER*/;
 
     default:
 
       return 70/*TokenKind.IDENTIFIER*/;
 
   }
 }
 // ********** Code for TokenizerHelpers **************
 function TokenizerHelpers() {}
 TokenizerHelpers.isIdentifierStart = function(c) {
-  return $assert_bool(((c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c == 95));
+  return ($notnull_bool(($notnull_bool(c >= 97 && c <= 122)) || ($notnull_bool(c >= 65 && c <= 90))) || c == 95);
 }
 TokenizerHelpers.isDigit = function(c) {
-  return $assert_bool((c >= 48 && c <= 57));
+  return ($notnull_bool(c >= 48 && c <= 57));
 }
 TokenizerHelpers.isHexDigit = function(c) {
-  return $assert_bool((TokenizerHelpers.isDigit(c) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70)));
+  return ($notnull_bool(TokenizerHelpers.isDigit(c) || ($notnull_bool(c >= 97 && c <= 102))) || ($notnull_bool(c >= 65 && c <= 70)));
 }
 TokenizerHelpers.isWhitespace = function(c) {
-  return $assert_bool((c == 32 || c == 9 || c == 10 || c == 13));
+  return ($notnull_bool(c == 32 || c == 9) || c == 10 || c == 13);
 }
 TokenizerHelpers.isIdentifierPart = function(c) {
-  return $assert_bool((TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c)));
+  return ($notnull_bool(TokenizerHelpers.isIdentifierStart(c) || TokenizerHelpers.isDigit(c)));
 }
 // ********** Code for TokenKind **************
 function TokenKind() {}
 TokenKind.kindToString = function(kind) {
   switch (kind) {
     case 1/*TokenKind.END_OF_FILE*/:
 
       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 $assert_bool(kind >= 70/*TokenKind.IDENTIFIER*/ && kind < 88/*TokenKind.BREAK*/);
+  return $notnull_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 329 matching lines @@
   this.diet = diet;
   this.throwOnIncomplete = throwOnIncomplete;
   this.optionalSemicolons = optionalSemicolons;
   // Initializers done
   this.tokenizer = new Tokenizer(this.source, true, startOffset);
   this._peekToken = this.tokenizer.next();
   this._previousToken = null;
   this._inInitializers = false;
 }
 lang_Parser.prototype.isPrematureEndOfFile = function() {
-  if ($notnull_bool(this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/))) {
+  if ($notnull_bool(this.throwOnIncomplete && this._maybeEat(1/*TokenKind.END_OF_FILE*/)) || this._maybeEat(68/*TokenKind.INCOMPLETE_MULTILINE_STRING_DQ*/) || this._maybeEat(69/*TokenKind.INCOMPLETE_MULTILINE_STRING_SQ*/)) {
     $throw(new IncompleteSourceException(this._previousToken));
   }
   else if ($notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
     this._lang_error('unexpected end of file', this._peekToken.get$span());
     return true;
   }
   else {
     return false;
   }
 }
@@ skipping 530 matching lines @@
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
     cases.add(this.caseNode());
   }
   return new SwitchStatement(test, cases, this._makeSpan(start));
 }
 lang_Parser.prototype._peekCaseEnd = function() {
   var kind = this._peek();
-  return $eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 89/*TokenKind.CASE*/) || $eq(kind, 93/*TokenKind.DEFAULT*/);
+  return $notnull_bool($eq(kind, 7/*TokenKind.RBRACE*/) || $eq(kind, 89/*TokenKind.CASE*/)) || $eq(kind, 93/*TokenKind.DEFAULT*/);
 }
 lang_Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
   var label = null;
   if ($notnull_bool(this._peekIdentifier())) {
     label = this.identifier();
     this._eat(8/*TokenKind.COLON*/);
   }
   var cases = [];
   while ($notnull_bool(true)) {
@@ skipping 258 matching lines @@
       if ($notnull_bool(this._peekIdentifier())) {
         return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
       }
       else {
         return expr;
       }
 
   }
 }
 lang_Parser.prototype._isBin = function(expr, kind) {
-  return (expr instanceof BinaryExpression) && expr.op.kind == kind;
+  return $notnull_bool((expr instanceof BinaryExpression) && expr.op.kind == kind);
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.boolType);
 }
 lang_Parser.prototype._intTypeRef = function(span) {
   return new TypeReference(span, world.intType);
 }
 lang_Parser.prototype._doubleTypeRef = function(span) {
   return new TypeReference(span, world.doubleType);
 }
@@ skipping 161 matching lines @@
   }
   else if ($notnull_bool($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
-  if ($notnull_bool(!$notnull_bool(this._inInitializers) && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/)))) {
+  if ($notnull_bool(!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/))))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     if ($notnull_bool(args.length == 1)) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
@@ skipping 1242 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 $assert_bool(this.get$isVar() || this.get$isFunction());
+  return $notnull_bool(this.get$isVar() || this.get$isFunction());
 }
 lang_Type.prototype.getCallMethod = function() {
   return null;
 }
 lang_Type.prototype.get$isClosed = function() {
-  return $assert_bool(this.get$isString() || this.get$isBool() || this.get$isNum() || this.get$isFunction() || this.get$isVar());
+  return $notnull_bool(this.get$isString() || this.get$isBool()) || this.get$isNum() || this.get$isFunction() || this.get$isVar();
 }
 lang_Type.prototype.get$isUsed = function() {
   return false;
 }
 lang_Type.prototype.get$isGeneric = function() {
   return false;
 }
 lang_Type.prototype.get$isNativeType = function() {
   return false;
 }
@@ skipping 62 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 $assert_bool(this.isSubtypeOf(other) || other.isSubtypeOf(this));
+  return $notnull_bool(this.isSubtypeOf(other) || other.isSubtypeOf(this));
 }
 lang_Type.prototype._isDirectSupertypeOf = function(other) {
   var $this = this; // closure support
   if ($notnull_bool(other.get$isClass())) {
-    return $assert_bool($eq(other.get$parent(), this) || this.get$isObject() && other.get$parent() == null);
+    return $notnull_bool($eq(other.get$parent(), this) || $notnull_bool(this.get$isObject() && other.get$parent() == null));
   }
   else {
     if ($notnull_bool(other.get$interfaces() == null || other.get$interfaces().isEmpty())) {
       return this.get$isObject();
     }
     else {
       return other.get$interfaces().some((function (i) {
         return $eq(i, $this);
       })
       );
     }
   }
 }
 lang_Type.prototype.isSubtypeOf = function(other) {
   if ($notnull_bool((other instanceof ParameterType))) {
     return true;
   }
   if ($notnull_bool($eq(this, other))) return true;
   if ($notnull_bool(this.get$isVar())) return true;
   if ($notnull_bool(other.get$isVar())) return true;
   if ($notnull_bool(other._isDirectSupertypeOf(this))) return true;
   var call = this.getCallMethod();
   var otherCall = other.getCallMethod();
   if ($notnull_bool($ne(call, null) && $ne(otherCall, null))) {
     return lang_Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
   }
-  if ($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null) && $ne(other.get$typeArgsInOrder(), null) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length)) {
+  if ($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null)) && $ne(other.get$typeArgsInOrder(), null) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length) {
     var t = this.get$typeArgsInOrder().iterator();
     var s = other.get$typeArgsInOrder().iterator();
     while ($notnull_bool(t.hasNext())) {
       if ($notnull_bool(!$notnull_bool(t.next().isSubtypeOf(s.next())))) return false;
     }
     return true;
   }
   if ($notnull_bool(this.get$parent() != null && this.get$parent().isSubtypeOf(other))) {
     return true;
   }
@@ skipping 141 matching lines @@
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams(this));
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.getCallMethod = function() {
   return this.genericType.getCallMethod();
 }
 ConcreteType.prototype.getAllMembers = function() {
-  var $0;
   var result = this.genericType.getAllMembers();
   var $list = result.getKeys();
   for (var $i = result.getKeys().iterator(); $i.hasNext(); ) {
     var memberName = $i.next();
     var myMember = this.members.$index(memberName);
     if ($notnull_bool($ne(myMember, null))) {
       result.$setindex(memberName, myMember);
     }
   }
   return (result && result.is$Map$String$Member());
@@ skipping 32 matching lines @@
 ConcreteType.prototype.getMember = function(memberName) {
   var ret = this.members.$index(memberName);
   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 && 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 && 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);
   }
@@ skipping 74 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 $assert_bool(this.library.get$isCore() && this.name == 'Object');
+  return $notnull_bool(this.library.get$isCore() && this.name == 'Object');
 }
 DefinedType.prototype.get$isString = function() {
-  return $assert_bool(this.library.get$isCore() && this.name == 'String' || this.library.get$isCoreImpl() && this.name == 'StringImplementation');
+  return $notnull_bool(this.library.get$isCore() && this.name == 'String') || $notnull_bool(this.library.get$isCoreImpl() && this.name == 'StringImplementation');
 }
 DefinedType.prototype.get$isBool = function() {
-  return $assert_bool(this.library.get$isCore() && this.name == 'bool');
+  return $notnull_bool(this.library.get$isCore() && this.name == 'bool');
 }
 DefinedType.prototype.get$isFunction = function() {
-  return $assert_bool(this.library.get$isCore() && this.name == 'Function');
+  return $notnull_bool(this.library.get$isCore() && this.name == 'Function');
 }
 DefinedType.prototype.get$isList = function() {
-  return $assert_bool(this.library.get$isCore() && this.name == 'List');
+  return $notnull_bool(this.library.get$isCore() && this.name == 'List');
 }
 DefinedType.prototype.get$isGeneric = function() {
   return this.typeParameters != null;
 }
 DefinedType.prototype.get$span = function() {
   var $0;
   return (($0 = $notnull_bool(this.definition == null) ? null : this.definition.span) && $0.is$SourceSpan());
 }
 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 $assert_bool(this.library != null && this.library.get$isCore() && (this.name == 'num' || this.name == 'int' || this.name == 'double'));
+  return $notnull_bool(this.library != null && this.library.get$isCore()) && ($notnull_bool(this.name == 'num' || this.name == 'int') || this.name == 'double');
 }
 DefinedType.prototype.getCallMethod = function() {
   var $0;
   return (($0 = this.members.$index('\$call')) && $0.is$MethodMember());
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if ($notnull_bool(this.isUsed)) return;
@@ skipping 16 matching lines @@
     if ($notnull_bool(this._lazyGenMethods == null)) this._lazyGenMethods = $map([]);
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
   if ($notnull_bool(types == null)) return [];
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
-    if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool((this.library.get$isCore() || this.library.get$isCoreImpl())))) {
+    if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool(($notnull_bool(this.library.get$isCore() || this.library.get$isCoreImpl()))))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
     interfaces.add(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
   $assert(this._subtypes == null, "_subtypes == null", "type.dart", 680, 12);
   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);
       this._subtypes.addAll(st.get$subtypes());
     }
   }
   return this._subtypes;
@@ skipping 12 matching lines @@
     seen.add(ancestor);
     ancestor = ancestor.get$parent();
   }
   return false;
 }
 DefinedType.prototype._cycleInInterfaceExtends = function() {
   var $this = this; // closure support
   var seen = new HashSetImplementation();
   seen.add(this);
   function _helper(ancestor) {
-    var $0;
     if ($notnull_bool(ancestor == null)) return false;
     if ($notnull_bool(ancestor === $this)) return true;
     if ($notnull_bool(seen.contains(ancestor))) {
       return false;
     }
     seen.add(ancestor);
     if ($notnull_bool($ne(ancestor.get$interfaces(), null))) {
       var $list = ancestor.get$interfaces();
       for (var $i = ancestor.get$interfaces().iterator(); $i.hasNext(); ) {
         var parent = $i.next();
@@ skipping 89 matching lines @@
   if ($notnull_bool(methodName == null)) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if ($notnull_bool(method.get$isConstructor())) {
     if ($notnull_bool(this.constructors.containsKey(method.get$constructorName()))) {
       world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1 && $eq(definition.modifiers.$index(0).kind, 75/*TokenKind.FACTORY*/))) {
+  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1) && $eq(definition.modifiers.$index(0).kind, 75/*TokenKind.FACTORY*/)) {
     if ($notnull_bool(this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null)) {
       world.error(('duplicate factory definition of "' + method.get$name() + '"'), definition.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), $assert_String(method.get$name()), (method && method.is$Member()));
     return;
   }
   if ($notnull_bool(methodName.startsWith('get\$') || methodName.startsWith('set\$'))) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
@@ skipping 60 matching lines @@
       return this.factory_.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
   var $0;
-  if ($notnull_bool(name == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0)) {
+  if ($notnull_bool(name == '' && this.definition != null) && this.isClass && this.constructors.get$length() == 0) {
     var span = this.definition.span;
     var inits = null, body = null;
     if ($notnull_bool(this.isNativeType)) {
       body = new NativeStatement(null, (span && span.is$SourceSpan()));
       inits = null;
     }
     else {
       body = null;
       inits = [new CallExpression(new SuperExpression((span && span.is$SourceSpan())), [], (span && span.is$SourceSpan()))];
     }
@@ skipping 264 matching lines @@
 // ********** 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) {
+function Value(type, code, span, needsTemp) {
+  this.isSuper = false
+  this.isType = false
   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;
+  if ($notnull_bool(this.type == null)) world.internalError('type passed as null', this.span);
 }
 Value.prototype.is$Value = function(){return this;};
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.set$span = function(value) { return this.span = value; };
 Value.prototype.get$_typeIsVarOrParameterType = function() {
-  return $assert_bool(this.type.get$isVar() || (this.type instanceof ParameterType));
+  return $notnull_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))) {
@@ skipping 11 matching lines @@
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
   if ($notnull_bool(this.get$_typeIsVarOrParameterType() && name == '\$ne')) {
     if ($notnull_bool(args.values.length != 1)) {
       world.warning('wrong number of arguments for !=', node.span);
     }
     world.gen.corejs.useOperator('\$ne');
-    return new Value(null, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), node.span, false, true, false);
+    return new Value(world.varType, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), node.span, true);
   }
   if ($notnull_bool(name == '\$call')) {
     if ($notnull_bool(this.isType)) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
     if ($notnull_bool(this.type.needsVarCall(args))) {
       return this._varCall(context, args);
     }
   }
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool(member == null)) {
     return this.invokeNoSuchMethod(context, name, node, args);
   }
   else {
     return member.invoke(context, node, this, args, isDynamic);
   }
 }
 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 $assert_bool($ne(member, null) && member.canInvoke(context, args));
+  return $notnull_bool($ne(member, null) && member.canInvoke(context, args));
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
   if ($notnull_bool(this.isSuper)) {
     var m = this.type.getMember('noSuchMethod');
-    return $assert_bool($ne(m, null) && !$notnull_bool(m.declaringType.get$isObject()));
+    return $notnull_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 {
     return this.type.resolveMember(name);
   }
 }
 Value.prototype._resolveMember = function(context, name, node, isDynamic) {
   var member;
   if ($notnull_bool(!$notnull_bool(this.get$_typeIsVarOrParameterType()))) {
     member = this._tryResolveMember(context, name);
-    if ($notnull_bool($ne(member, null) && this.isType && !$notnull_bool(member.get$isStatic()))) {
+    if ($notnull_bool($ne(member, null) && this.isType) && !$notnull_bool(member.get$isStatic())) {
       if ($notnull_bool(!$notnull_bool(isDynamic))) {
         world.error('can not refer to instance member as static', node.span);
       }
       return null;
     }
-    if ($notnull_bool(member == null && !$notnull_bool(isDynamic) && !$notnull_bool(this._hasOverriddenNoSuchMethod()))) {
+    if ($notnull_bool(member == null && !$notnull_bool(isDynamic)) && !$notnull_bool(this._hasOverriddenNoSuchMethod())) {
       var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
       var message = ('can not resolve "' + name + '" on "' + typeName + '"');
       if ($notnull_bool(this.isType)) {
         world.error($assert_String(message), node.span);
       }
       else {
         world.warning($assert_String(message), node.span);
       }
     }
   }
-  if ($notnull_bool(member == null && !$notnull_bool(this.isSuper) && !$notnull_bool(this.isType))) {
+  if ($notnull_bool(member == null && !$notnull_bool(this.isSuper)) && !$notnull_bool(this.isType)) {
     member = context.findMembers(name);
     if ($notnull_bool(member == null && !$notnull_bool(isDynamic))) {
       world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
     }
   }
   return member;
 }
 Value.prototype.checkFirstClass = function(span) {
   if ($notnull_bool(this.isType)) {
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
-  return new Value(null, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), this.span, false, true, false);
+  return new Value(world.varType, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), this.span, true);
 }
 Value.prototype.needsConversion = function(toType) {
   var callMethod = toType.getCallMethod();
   if ($notnull_bool($ne(callMethod, null))) {
     var arity = callMethod.get$parameters().length;
     var myCall = this.type.getCallMethod();
     if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
       return true;
     }
   }
   if ($notnull_bool(options.enableTypeChecks)) {
     var fromType = this.type;
     if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
       fromType = world.objectType;
     }
-    var bothNum = $assert_bool(this.type.get$isNum() && toType.get$isNum());
-    return $assert_bool(fromType.isSubtypeOf(toType) || bothNum);
+    var bothNum = $notnull_bool(this.type.get$isNum() && toType.get$isNum());
+    return $notnull_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);
+      var val = new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), node.span, true);
       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());
-  if ($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType) || bothNum)) {
+  var bothNum = $notnull_bool(this.type.get$isNum() && toType.get$isNum());
+  if ($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType)) || bothNum) {
     return this;
   }
   if ($notnull_bool(!$notnull_bool(toType.isSubtypeOf(this.type)))) {
     this.convertWarning(toType, node);
   }
   if ($notnull_bool(options.enableTypeChecks)) {
     return this._typeAssert(context, toType, node);
   }
   else {
     return this;
   }
 }
 Value.prototype.convertToNonNullBool = function(context, node) {
   if ($notnull_bool(!$notnull_bool(this.type.isAssignable(world.boolType)))) {
     this.convertWarning(world.boolType, node);
   }
   if ($notnull_bool(!$notnull_bool(options.enableTypeChecks))) {
     return this;
   }
   else {
     if ($notnull_bool(this.code.startsWith('\$notnull_bool'))) {
       return this;
     }
     else {
       world.gen.corejs.useNotNullBool = true;
-      return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), this.span, false, true, false);
+      return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), this.span, true);
     }
   }
 }
 Value.prototype._isDomCallback = function(toType) {
-  return $assert_bool(((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom())));
+  return ($notnull_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);
+  return new Value(toType, ('\$wrap_call\$' + arity + '(' + this.code + ')'), this.span, true);
 }
 Value.prototype._typeAssert = function(context, toType, node) {
   if ($notnull_bool((toType instanceof ParameterType))) {
     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;
@@ skipping 10 matching lines @@
       toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  throw new TypeError(\"'\" + x + \"' is not a " + toType.name + ".\");\n}");
     }
   }
   else {
     toType.isTested = true;
     var temp = context.getTemp(this);
     check = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     check = check + (' ' + temp.code + '.is\$' + toType.get$jsname() + '())');
     if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
   }
-  return new Value(toType, check, this.span, false, true, false);
+  return new Value(toType, check, this.span, true);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if ($notnull_bool(toType.get$isVar())) {
     world.error('can not resolve type', span);
     return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
   }
   if ($notnull_bool((toType instanceof ParameterType))) {
     return EvaluatedValue.EvaluatedValue$factory(world.boolType, true, 'true', null);
   }
   var testCode = null;
@@ skipping 16 matching lines @@
     testCode = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     testCode = testCode + (' ' + temp.code + '.is\$' + toType.get$jsname() + ')');
     if ($notnull_bool(isTrue)) {
       testCode = '!!' + testCode;
     }
     else {
       testCode = '!' + testCode;
     }
     if ($notnull_bool($ne(this, temp))) context.freeTemp((temp && temp.is$Value()));
   }
-  return new Value(world.boolType, testCode, span, false, true, false);
+  return new Value(world.boolType, testCode, span, true);
 }
 Value.prototype.convertWarning = function(toType, node) {
   world.warning(('type "' + this.type.name + '" is not assignable to "' + toType.name + '"'), node.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   var $0;
   var pos = '';
   if ($notnull_bool(args != null)) {
     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)];
+  var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), node.span, true), new Value(world.listType, ('[' + pos + ']'), node.span, true)];
   return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 461, 12);
-  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 462, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 464, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 465, 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);
+    return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, true);
   }
   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);
+    return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), this.span, true);
   }
 }
 Value.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), $assert_String($1), ($2 && $2.is$lang_Node()), ($3 && $3.is$Arguments()), false);
 }
 ;
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
 EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, span, code) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
-  Value.call(this, type, code, span, false, false, false);
+  Value.call(this, type, code, span, false);
   // Initializers done
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
 EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, span) {
   return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
 EvaluatedValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 EvaluatedValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 EvaluatedValue.codeWithComments = function(canonicalCode, span) {
-  return $notnull_bool((span != null && span.get$text() != canonicalCode)) ? ('' + canonicalCode + '/*' + span.get$text() + '*/') : canonicalCode;
+  return $notnull_bool(($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
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
@@ skipping 20 matching lines @@
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
   this.fields = fields;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
 $inherits(ConstObjectValue, EvaluatedValue);
 ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, span) {
-  var $0;
   var fieldValues = [];
   var $list = fields.getKeys();
   for (var $i = fields.getKeys().iterator(); $i.hasNext(); ) {
     var f = $i.next();
     fieldValues.add(('' + f + ' = ' + fields.$index(f).get$actualValue() + ''));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo(b);
   })
   );
   var actualValue = ('const ' + type.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
   return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
 // ********** Code for GlobalValue **************
 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);
+  Value.call(this, type, code, span, !$notnull_bool(isConst));
   // 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.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 $assert_bool(this.exp.get$isConst() && (this.field == null || this.field.isFinal));
+  return $notnull_bool(this.exp.get$isConst() && ($notnull_bool(this.field == null || this.field.isFinal)));
 }
 GlobalValue.prototype.get$actualValue = function() {
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
   if ($notnull_bool($eq(other, this))) {
     return 0;
   }
   else if ($notnull_bool(this.dependencies.indexOf(other, 0) >= 0)) {
     return 1;
@@ skipping 16 matching lines @@
   else if ($notnull_bool(this.name != null)) {
     return this.name.compareTo(other.name);
   }
   else {
     return this.field.name.compareTo(other.field.name);
   }
 }
 // ********** Code for BareValue **************
 function BareValue(home, outermost, span) {
   this.home = home;
-  Value.call(this, outermost.method.declaringType, null, span, false, false, outermost.get$isStatic());
+  Value.call(this, outermost.method.declaringType, null, span, false);
   // Initializers done
+  this.isType = outermost.get$isStatic();
 }
 $inherits(BareValue, Value);
 BareValue.prototype._tryResolveMember = function(context, name) {
-  $assert($eq(context, this.home), "context == home", "value.dart", 665, 12);
+  $assert($eq(context, this.home), "context == home", "value.dart", 669, 12);
   var member = this.type.resolveMember(name);
   if ($notnull_bool($ne(member, null))) {
-    $assert(this.code == null, "code == null", "value.dart", 670, 14);
+    $assert(this.code == null, "code == null", "value.dart", 674, 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 168 matching lines @@
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
     $this.resolveAll();
   })
   );
   this.withTiming('generate code', (function () {
-    var $0;
     var mainMembers = lib.topType.resolveMember('main');
     var main = null;
     if ($notnull_bool(mainMembers == null || mainMembers.get$members().length == 0)) {
       $this.fatal('no main method specified');
     }
     else if ($notnull_bool(mainMembers.get$members().length > 1)) {
       var $list = mainMembers.get$members();
       for (var $i = mainMembers.get$members().iterator(); $i.hasNext(); ) {
         var m = $i.next();
         main = m;
@@ skipping 56 matching lines @@
       lib.visitSources();
     }
   }
 }
 World.prototype.processScript = function(filename) {
   var library = this.getOrAddLibrary(filename);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
-  var $0;
   var $list = this.libraries.getValues();
   for (var $i = this.libraries.getValues().iterator(); $i.hasNext(); ) {
     var lib = $i.next();
     lib.resolve();
   }
 }
 World.prototype._message = function(message, span, span1, span2, throwing) {
   var text = message;
   if ($notnull_bool(span != null)) {
     text = span.toMessageString(message);
@@ skipping 15 matching lines @@
 }
 World.prototype.warning = function(message, span, span1, span2) {
   this.warnings++;
   if ($notnull_bool(options.showWarnings)) {
     this._message(('warning: ' + message + ''), span, span1, span2, options.throwOnWarnings);
   }
 }
 World.prototype.fatal = function(message, span, span1, span2) {
   this.errors++;
   this.seenFatal = true;
-  this._message(('fatal: ' + message + ''), span, span1, span2, $assert_bool(options.throwOnFatal || options.throwOnErrors));
+  this._message(('fatal: ' + message + ''), span, span1, span2, $notnull_bool(options.throwOnFatal || options.throwOnErrors));
 }
 World.prototype.internalError = function(message, span, span1, span2) {
   this._message(('We are sorry, but... ' + message + ''), span, span1, span2, true);
 }
 World.prototype.info = function(message, span, span1, span2) {
   if ($notnull_bool(options.showInfo)) {
     this._message(('info: ' + message + ''), span, span1, span2, false);
   }
 }
 World.prototype.get$hasErrors = function() {
@@ skipping 168 matching lines @@
 function VarMember(name) {
   this.name = name;
   // Initializers done
 }
 VarMember.prototype.is$VarMember = function(){return this;};
 VarMember.prototype.get$name = function() { return this.name; };
 VarMember.prototype.get$returnType = function() {
   return world.varType;
 }
 VarMember.prototype.invoke = function(context, node, target, args) {
-  return new Value(this.get$returnType(), ('' + target.code + '.' + this.name + '(' + args.getCode() + ')'), node.span, false, true, false);
+  return new Value(this.get$returnType(), ('' + target.code + '.' + this.name + '(' + args.getCode() + ')'), node.span, true);
 }
 VarMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 }
 ;
 // ********** Code for VarFunctionStub **************
 function VarFunctionStub(name, callArgs) {
   this.args = callArgs.toCallStubArgs();
   VarMember.call(this, name);
   // Initializers done
@@ skipping 96 matching lines @@
 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++) {
     var member = $list.$index($i);
-    var target = new Value(member.declaringType, 'this', node.span, false, true, false);
+    var target = new Value(member.declaringType, 'this', node.span, true);
     var result = member.invoke$4(context, node, target, this.args);
     var stub = new VarMethodStub(this.name, member, this.args, result);
     var type = member.declaringType;
     if ($notnull_bool($ne(type.get$library(), world.get$dom()) && !$notnull_bool(type.get$isObject()))) {
       VarMethodSet._addVarStub((type && type.is$lang_Type()), (stub && stub.is$VarMember()));
     }
     else {
       this._fallbackStubs.add(stub);
     }
   }
-  var target = new Value(world.objectType, 'this', node.span, false, true, false);
+  var target = new Value(world.objectType, 'this', node.span, true);
   var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
   var stub = new VarMethodStub(this.name, null, this.args, result);
   if ($notnull_bool(this._fallbackStubs.length == 0)) {
     VarMethodSet._addVarStub(world.objectType, (stub && stub.is$VarMember()));
   }
   else {
     this._fallbackStubs.add(stub);
     world.gen.corejs.useVarMethod = true;
   }
 }
@@ skipping 13 matching lines @@
     code.writeln($notnull_bool($eq(stub, lastOne)) ? '' : ',');
   }
   code.exitBlock('});');
 }
 VarMethodSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 }
 ;
 // ********** Code for top level **************
 function map(source, mapper) {
-  var $0;
   var result = new ListFactory();
   if ($notnull_bool(!!(source && source.is$List))) {
     var list = (source && source.is$List());
     result.length = list.length;
     for (var i = 0;
      $notnull_bool(i < list.length); i++) {
       result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
@@ skipping 23 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 $assert_bool(text.startsWith('"""') || text.startsWith("'''"));
+  return $notnull_bool(text.startsWith('"""') || text.startsWith("'''"));
 }
 function isRawMultilineString(text) {
-  return $assert_bool(text.startsWith('@"""') || text.startsWith("@'''"));
+  return $notnull_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 203 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);