unary operators

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 555 matching lines @@
 // ********** Code for ListIterator **************
 function ListIterator(array) {
   this._array = array;
   this._pos = 0;
   // Initializers done
 }
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
-  if ($notnull_bool(!this.hasNext())) {
+  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
 function ImmutableList(length0) {
   this._length = length0;
   ListFactory$E.call(this, length0);
   // Initializers done
 }
@@ skipping 590 matching lines @@
   }
   return set;
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
 HashSetImplementation.prototype.contains = function(value) {
   return this._backingMap.containsKey(value);
 }
 HashSetImplementation.prototype.remove = function(value) {
-  if ($notnull_bool(!this._backingMap.containsKey(value))) return false;
+  if ($notnull_bool(!$notnull_bool(this._backingMap.containsKey(value)))) return false;
   this._backingMap.remove(value);
   return true;
 }
 HashSetImplementation.prototype.addAll = function(collection) {
   var $this = this; // closure support
   collection.forEach(function _(value) {
     $this.add(value);
   }
   );
 }
@@ skipping 57 matching lines @@
   this._advance();
 }
 HashSetIterator.prototype.hasNext = function() {
   if ($notnull_bool(this._nextValidIndex >= this._entries.length)) return false;
   if ($notnull_bool(this._entries.$index(this._nextValidIndex) === HashMapImplementation._deletedKey)) {
     this._advance();
   }
   return this._nextValidIndex < this._entries.length;
 }
 HashSetIterator.prototype.next = function() {
-  if ($notnull_bool(!this.hasNext())) {
+  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   var res = this._entries.$index(this._nextValidIndex);
   this._advance();
   return res;
 }
 HashSetIterator.prototype._advance = function() {
   var length = this._entries.length;
   var entry;
   var deletedKey = HashMapImplementation._deletedKey;
@@ skipping 385 matching lines @@
 // ********** Code for _DoubleLinkedQueueIterator **************
 function _DoubleLinkedQueueIterator(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.hasNext = function() {
   return this._currentEntry._next !== this._sentinel;
 }
 _DoubleLinkedQueueIterator.prototype.next = function() {
-  if ($notnull_bool(!this.hasNext())) {
+  if ($notnull_bool(!$notnull_bool(this.hasNext()))) {
     $throw(const$0/*const NoMoreElementsException()*/);
   }
   this._currentEntry = this._currentEntry._next;
   return this._currentEntry.get$element();
 }
 // ********** Code for _DoubleLinkedQueueIterator$E **************
 function _DoubleLinkedQueueIterator$E(_sentinel) {
   this._sentinel = _sentinel;
   // Initializers done
   this._currentEntry = this._sentinel;
@@ skipping 180 matching lines @@
 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(!((other instanceof DateImplementation)))) return false;
+  if ($notnull_bool(!$notnull_bool(((other instanceof DateImplementation))))) return false;
   return (this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone));
 }
 DateImplementation.prototype.compareTo = function(other) {
   return this.value.compareTo(other.value);
 }
 DateImplementation.prototype.get$year = function() {
   return this.isUtc ? this._asJs().getUTCFullYear() :
       this._asJs().getFullYear();
 }
 DateImplementation.prototype.get$month = function() {
@@ skipping 52 matching lines @@
     return this.date;
 }
 // ********** Code for TimeZoneImplementation **************
 function TimeZoneImplementation() {}
 TimeZoneImplementation.local$ctor = function() {
   this.isUtc = false;
   // Initializers done
 }
 TimeZoneImplementation.local$ctor.prototype = TimeZoneImplementation.prototype;
 TimeZoneImplementation.prototype.$eq = function(other) {
-  if ($notnull_bool(!((other instanceof TimeZoneImplementation)))) return false;
+  if ($notnull_bool(!$notnull_bool(((other instanceof TimeZoneImplementation))))) return false;
   return $eq(this.isUtc, other.isUtc);
 }
 TimeZoneImplementation.prototype.toString = function() {
   if ($notnull_bool(this.isUtc)) return "TimeZone (UTC)";
   return "TimeZone (Local)";
 }
 // ********** Code for top level **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
@@ skipping 688 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.charOffset));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.byteOffset;
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!done)) {
+  while ($notnull_bool(!$notnull_bool(done))) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
@@ skipping 38 matching lines @@
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.charOffset));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 ArrayBasedScanner$String.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 208 matching lines @@
   return LinkFactory.Link$factory(element, this);
 }
 AbstractLink.prototype.iterator = function() {
   return this.toList().iterator();
 }
 AbstractLink.prototype.printOn = function(buffer, separatedBy) {
   var $0;
   if ($notnull_bool(this.isEmpty())) return;
   buffer.add(this.get$head());
   for (var link = this.get$tail();
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link())) {
     buffer.add(separatedBy);
     buffer.add(link.get$head());
   }
 }
 AbstractLink.prototype.toString = function() {
   var buffer = new StringBufferImpl("");
   buffer.add('[ ');
   this.printOn(buffer, ', ');
   buffer.add(' ]');
   return buffer.toString();
@@ skipping 86 matching lines @@
 LinkEntry.prototype.get$tail = function() {
   return this.realTail;
 }
 LinkEntry.prototype.isEmpty = function() {
   return false;
 }
 LinkEntry.prototype.toList = function() {
   var $0;
   var list = new ListFactory$T();
   for (var link = this;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$T())) {
     list.addLast(link.get$head());
   }
   return list;
 }
 // ********** Code for LinkEntry$T **************
 function LinkEntry$T(head, realTail) {
   this.head = head;
   this.realTail = realTail;
   // Initializers done
 }
@@ skipping 534 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 AbstractScanner.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!done)) {
+  while ($notnull_bool(!$notnull_bool(done))) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
@@ skipping 38 matching lines @@
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 681 matching lines @@
       case 99/*null.$c*/:
       case 100/*null.$d*/:
       case 101/*null.$e*/:
       case 102/*null.$f*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         this.appendByteStringToken(120/*null.HEXADECIMAL_TOKEN*/, this.asciiString(start));
         return next;
 
     }
   }
 }
 AbstractScanner$S.prototype.tokenizeDotOrNumber = function(next) {
   var start = this.get$byteOffset();
@@ skipping 21 matching lines @@
     default:
 
       this.appendStringToken(46/*null.PERIOD_TOKEN*/, ".");
       return next;
 
   }
 }
 AbstractScanner$S.prototype.tokenizeFractionPart = function(next, start) {
   var done = false;
   LOOP:
-  while ($notnull_bool(!done)) {
+  while ($notnull_bool(!$notnull_bool(done))) {
     switch (next) {
       case 48/*null.$0*/:
       case 49/*null.$1*/:
       case 50/*null.$2*/:
       case 51/*null.$3*/:
       case 52/*null.$4*/:
       case 53/*null.$5*/:
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
@@ skipping 38 matching lines @@
       case 54/*null.$6*/:
       case 55/*null.$7*/:
       case 56/*null.$8*/:
       case 57/*null.$9*/:
 
         hasDigits = true;
         break;
 
       default:
 
-        if ($notnull_bool(!hasDigits)) {
+        if ($notnull_bool(!$notnull_bool(hasDigits))) {
           $throw(new MalformedInputException(this.get$charOffset()));
         }
         return next;
 
     }
     next = this.advance();
   }
 }
 AbstractScanner$S.prototype.tokenizeSlashOrComment = function(next) {
   next = this.advance();
@@ skipping 313 matching lines @@
   }
   return token;
 }
 Parser.prototype.parseFactoryClauseOpt = function(token) {
   if ($notnull_bool(this.optional(const$195/*Keyword.FACTORY*/, token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 Parser.prototype.skipBlock = function(token) {
-  if ($notnull_bool(!this.optional(const$232/*const SourceString("{")*/, token))) {
+  if ($notnull_bool(!$notnull_bool(this.optional(const$232/*const SourceString("{")*/, token)))) {
     return this.listener.expectedBlock(token);
   }
   token = this.next(token);
   var nesting = 1;
   do {
     switch (token.kind) {
       case 123/*null.LBRACE_TOKEN*/:
 
         nesting++;
         break;
@@ skipping 42 matching lines @@
 Parser.prototype.parseIdentifier = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.identifier(token);
   }
   else {
     this.listener.notIdentifier(token);
   }
   return this.next(token);
 }
 Parser.prototype.parseTypeVariablesOpt = function(token) {
-  if ($notnull_bool(!this.optional(const$228/*const SourceString("<")*/, token))) {
+  if ($notnull_bool(!$notnull_bool(this.optional(const$228/*const SourceString("<")*/, token)))) {
     return token;
   }
   this.listener.beginTypeVariables(token);
   do {
     token = this.parseTypeVariable(this.next(token));
   }
   while ($notnull_bool(this.optional(const$230/*const SourceString(",")*/, token)))
   return this.expect(const$231/*const SourceString(">")*/, token);
 }
 Parser.prototype.expect = function(string, token) {
@@ skipping 83 matching lines @@
   }
   else if ($notnull_bool(this.optional(const$238/*const SourceString("=")*/, token) || this.optional(const$236/*const SourceString(";")*/, token))) {
     this.listener.topLevelField(start);
   }
   else {
     token = this.listener.unexpected(token);
   }
   while ($notnull_bool(token != null && token.kind != 123/*null.LBRACE_TOKEN*/ && token.kind != 59/*null.SEMICOLON_TOKEN*/)) {
     token = this.next(token);
   }
-  if ($notnull_bool(!this.optional(const$236/*const SourceString(";")*/, token))) {
+  if ($notnull_bool(!$notnull_bool(this.optional(const$236/*const SourceString(";")*/, token)))) {
     token = this.skipBlock(token);
   }
   this.listener.endTopLevelMember(token);
   return token.next;
 }
 Parser.prototype.parseLibraryTags = function(token) {
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect(const$234/*const SourceString("(")*/, token);
   while ($notnull_bool(token != null && token.kind != 40/*null.LPAREN_TOKEN*/ && token.kind != 41/*null.RPAREN_TOKEN*/)) {
@@ skipping 37 matching lines @@
 }
 BodyParser.prototype.parseFunctionBody = function(token) {
   if ($notnull_bool(this.optional(const$236/*const SourceString(";")*/, token))) {
     this.listener.endFunctionBody(0, null, token);
     return token.next;
   }
   var begin = token;
   var statementCount = 0;
   this.listener.beginFunctionBody(begin);
   token = this.checkEof(this.expect(const$232/*const SourceString("{")*/, token));
-  while ($notnull_bool(!this.optional(const$239/*const SourceString("}")*/, token))) {
+  while ($notnull_bool(!$notnull_bool(this.optional(const$239/*const SourceString("}")*/, token)))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endFunctionBody(statementCount, begin, token);
   return this.expect(const$239/*const SourceString("}")*/, token);
 }
 BodyParser.prototype.parseStatement = function(token) {
   this.checkEof(token);
   if ($notnull_bool($eq(token.get$value(), const$240/*const SourceString('{')*/))) {
     return this.parseBlock(token);
@@ skipping 290 matching lines @@
   return token.next;
 }
 BodyParser.prototype.parseSend = function(token) {
   this.listener.beginSend(token);
   token = this.parseIdentifier(token);
   token = this.parseArgumentsOpt(token);
   this.listener.endSend(token);
   return token;
 }
 BodyParser.prototype.parseArgumentsOpt = function(token) {
-  if ($notnull_bool(!this.optional(const$234/*const SourceString("(")*/, token))) {
+  if ($notnull_bool(!$notnull_bool(this.optional(const$234/*const SourceString("(")*/, token)))) {
     this.listener.handleNoArgumentsOpt(token);
     return token;
   }
   else return this.parseArguments(token);
 }
 BodyParser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
   $assert($eq(const$234/*const SourceString("(")*/, token.get$value()), "const SourceString(\"(\") == token.value", "leg/scanner/parser.dart", 559, 12);
   var argumentCount = 0;
@@ skipping 50 matching lines @@
     token = this.parseStatement(token.next);
   }
   this.listener.endIfStatement(ifToken, elseToken);
   return token;
 }
 BodyParser.prototype.parseBlock = function(token) {
   var begin = token;
   this.listener.beginBlock(begin);
   var statementCount = 0;
   token = this.expect(const$240/*const SourceString('{')*/, token);
-  while ($notnull_bool(!this.optional(const$239/*const SourceString("}")*/, token))) {
+  while ($notnull_bool(!$notnull_bool(this.optional(const$239/*const SourceString("}")*/, token)))) {
     token = this.parseStatement(token);
     ++statementCount;
   }
   this.listener.endBlock(statementCount, begin, token);
   return this.expect(const$239/*const SourceString("}")*/, token);
 }
 // ********** Code for Listener **************
 function Listener(canceler) {
   this.classCount = 0
   this.aliasCount = 0
@@ skipping 197 matching lines @@
 }
 BodyListener.prototype.handleBinaryExpression = function(token) {
   var arguments = new NodeList(null, LinkFactory.Link$factory(this.popNode()), null, null);
   this.pushNode(new Send(this.popNode(), new Operator(token), arguments));
 }
 BodyListener.prototype.handleAssignmentExpression = function(token) {
   var arguments = new NodeList.singleton$ctor(this.popNode());
   var node = this.popNode();
   if ($notnull_bool(!(node instanceof Send))) this.canceler.cancel(('not assignable: ' + node + ''));
   var send = node;
-  if ($notnull_bool(!send.get$isPropertyAccess())) this.canceler.cancel(('not assignable: ' + node + ''));
+  if ($notnull_bool(!$notnull_bool(send.get$isPropertyAccess()))) this.canceler.cancel(('not assignable: ' + node + ''));
   if ($notnull_bool((send instanceof SetterSend))) this.canceler.cancel('chained assignment');
   this.pushNode(new SetterSend(send.receiver, send.selector, token, arguments));
 }
 BodyListener.prototype.handleConditionalExpression = function(question, colon) {
   var elseExpression = this.popNode();
   var thenExpression = this.popNode();
   var condition = this.popNode();
   this.canceler.cancel('conditional expression not implemented yet');
 }
 BodyListener.prototype.beginSend = function(token) {
@@ skipping 71 matching lines @@
 BodyListener.prototype.endBlock = function(count, beginToken, endToken) {
   this.pushNode(new Block(this.makeNodeList(count, beginToken, endToken, null)));
 }
 BodyListener.prototype.pushNode = function(node) {
   var $0;
   this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link$Node());
   this.logger.log(("push " + this.nodes + ""));
 }
 BodyListener.prototype.popNode = function() {
   var $0;
-  $assert(!this.nodes.isEmpty(), "!nodes.isEmpty()", "leg/scanner/listener.dart", 360, 12);
+  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "leg/scanner/listener.dart", 360, 12);
   var node = this.nodes.get$head();
   this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link$Node());
   this.logger.log(("pop " + this.nodes + ""));
   return node;
 }
 BodyListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes0 = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   for (; $notnull_bool(count > 0); --count) {
     nodes0 = (($0 = nodes0.prepend(this.popNode())) && $0.is$Link$Node());
@@ skipping 309 matching lines @@
 NodeList.singleton$ctor.prototype = NodeList.prototype;
 $inherits(NodeList, Node);
 NodeList.prototype.accept = function(visitor) {
   return visitor.visitNodeList(this);
 }
 NodeList.prototype.getBeginToken = function() {
   var $0;
   if ($notnull_bool(this.beginToken != null)) return this.beginToken;
   if ($notnull_bool(this.nodes != null)) {
     for (var link = this.nodes;
-     $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+     $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       if ($notnull_bool(link.get$head().getBeginToken() != null)) {
         return link.get$head().getBeginToken();
       }
       if ($notnull_bool(link.get$head().getEndToken() != null)) {
         return link.get$head().getEndToken();
       }
     }
   }
   return this.endToken;
 }
 NodeList.prototype.getEndToken = function() {
   var $0;
   if ($notnull_bool(this.endToken != null)) return this.endToken;
   if ($notnull_bool(this.nodes != null)) {
     var link = this.nodes;
-    while ($notnull_bool(!link.get$tail().isEmpty())) link = (($0 = link.get$tail()) && $0.is$Link$Node());
+    while ($notnull_bool(!$notnull_bool(link.get$tail().isEmpty()))) link = (($0 = link.get$tail()) && $0.is$Link$Node());
     if ($notnull_bool(link.get$head().getEndToken() != null)) return link.get$head().getEndToken();
     if ($notnull_bool(link.get$head().getBeginToken() != null)) return link.get$head().getBeginToken();
   }
   return this.beginToken;
 }
 // ********** Code for Block **************
 function Block(statements) {
   this.statements = statements;
   // Initializers done
 }
@@ skipping 345 matching lines @@
 DebugUnparser.prototype.visitNodeList = function(node) {
   var $0;
   var first = true;
   if ($notnull_bool(node.beginToken != null)) this.sb.add(node.beginToken);
   if ($notnull_bool(node.nodes != null)) {
     var delimiter = node.delimiter;
     if ($notnull_bool(delimiter == null)) delimiter = new StringWrapper(this.separator);
     var $list = node.nodes;
     for (var $i = node.nodes.iterator(); $i.hasNext(); ) {
       var element = $i.next();
-      if ($notnull_bool(!first)) delimiter.printOn(this.sb);
+      if ($notnull_bool(!$notnull_bool(first))) delimiter.printOn(this.sb);
       first = false;
       this.visit(element);
     }
   }
   if ($notnull_bool(node.endToken != null)) this.sb.add(node.endToken);
 }
 DebugUnparser.prototype.visitOperator = function(node) {
   this.visitIdentifier(node);
 }
 DebugUnparser.prototype.visitParameter = function(node) {
@@ skipping 61 matching lines @@
   // Initializers done
 }
 $inherits(FunctionElement, Element);
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
   if ($notnull_bool(this.type != null)) return this.type;
   var node = this.parseNode(compiler, compiler);
   var returnType = getType(node.returnType, types);
   var parameterTypes = new LinkBuilderImplementation$Type();
   for (var link = node.parameters.nodes;
-   $notnull_bool(!link.isEmpty()); link = link.get$tail()) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = link.get$tail()) {
     compiler.cancel('parameters not supported.');
     var parameter = link.get$head();
     parameterTypes.addLast(getType(parameter.typeAnnotation, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return this.type;
 }
 // ********** Code for top level **************
 function getType(annotation, types) {
   if ($notnull_bool(annotation == null || annotation.typeName == null)) {
@@ skipping 69 matching lines @@
   this.stack.add(instruction);
 }
 SsaBuilder.prototype.pop = function() {
   return this.stack.removeLast();
 }
 SsaBuilder.prototype.visit = function(node) {
   if ($notnull_bool(node != null)) node.accept(this);
 }
 SsaBuilder.prototype.visitBlock = function(node) {
   this.visit(node.statements);
-  if ($notnull_bool(!this.stack.isEmpty())) this.compiler.cancel('non-empty instruction stack');
+  if ($notnull_bool(!$notnull_bool(this.stack.isEmpty()))) this.compiler.cancel('non-empty instruction stack');
 }
 SsaBuilder.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
   this.pop();
 }
 SsaBuilder.prototype.visitFunctionExpression = function(node) {
   this.compiler.cancel();
 }
 SsaBuilder.prototype.visitIdentifier = function(node) {
   this.compiler.cancel();
@@ skipping 22 matching lines @@
       this.push(new HDivide([left, right]));
     }
     else if ($notnull_bool($eq(const$262/*const SourceString("~/")*/, op.get$source()))) {
       this.push(new HTruncatingDivide([left, right]));
     }
   }
   else {
     this.visit(node.argumentsNode);
     var arguments = [];
     for (var link = node.get$arguments();
-     $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+     $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
       arguments.add(this.pop());
     }
     var selector = node.selector;
     this.push(new HInvoke(selector.get$source(), arguments));
   }
 }
 SsaBuilder.prototype.visitLiteralInt = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralDouble = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralBool = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitLiteralString = function(node) {
   this.push(new HLiteral(node.get$value()));
 }
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 SsaBuilder.prototype.visitOperator = function(node) {
   this.compiler.unimplemented("SsaBuilder::visitOperator");
 }
 SsaBuilder.prototype.visitParameter = function(node) {
   this.compiler.unimplemented("SsaBuilder::visitParameter");
 }
 SsaBuilder.prototype.visitReturn = function(node) {
@@ skipping 41 matching lines @@
 function SsaCodeGenerator(compiler, buffer) {
   this.compiler = compiler;
   this.buffer = buffer;
   // Initializers done
 }
 SsaCodeGenerator.prototype.visitGraph = function(graph) {
   var $this = this; // closure support
   function visitBasicBlockAndSuccessors(block) {
     var $0;
     $this.visit(block);
-    if ($notnull_bool(!block.successors.isEmpty())) {
+    if ($notnull_bool(!$notnull_bool(block.successors.isEmpty()))) {
       $assert(block.successors.length == 1, "block.successors.length == 1", "leg/ssa/codegen.dart", 39, 16);
       visitBasicBlockAndSuccessors((($0 = block.successors.$index(0)) && $0.is$HBasicBlock()));
     }
   }
   visitBasicBlockAndSuccessors(graph.entry);
 }
 SsaCodeGenerator.prototype.temporary = function(instruction) {
   return ('t' + instruction.id + '');
 }
 SsaCodeGenerator.prototype.invoke = function(selector, arguments) {
@@ skipping 20 matching lines @@
 }
 SsaCodeGenerator.prototype.visit = function(node) {
   return node.accept(this);
 }
 SsaCodeGenerator.prototype.visitAdd = function(node) {
   this.invoke(const$266/*const SourceString('\$add')*/, node.inputs);
 }
 SsaCodeGenerator.prototype.visitBasicBlock = function(node) {
   var instruction = node.first;
   while ($notnull_bool(instruction != null)) {
-    if ($notnull_bool(!instruction.canBeSkipped())) {
+    if ($notnull_bool(!$notnull_bool(instruction.canBeSkipped()))) {
       this.buffer.add('  ');
-      if ($notnull_bool(!instruction.get$usedBy().isEmpty())) {
+      if ($notnull_bool(!$notnull_bool(instruction.get$usedBy().isEmpty()))) {
         this.define(instruction);
       }
       else {
         this.visit(instruction);
       }
       this.buffer.add(';\n');
     }
     instruction = instruction.next;
   }
 }
@@ skipping 261 matching lines @@
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.$eq = function(other) {
   return false;
 }
 HInstruction.prototype.hashCode = function() {
   return 0;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
-  $assert(!this.isInBasicBlock(), "!isInBasicBlock()", "leg/ssa/nodes.dart", 283, 12);
+  $assert(!$notnull_bool(this.isInBasicBlock()), "!isInBasicBlock()", "leg/ssa/nodes.dart", 283, 12);
   this._usedBy = [];
   for (var i = 0;
    $notnull_bool(i < this.inputs.length); i++) {
     this.inputs.$index(i).get$usedBy().add(this);
   }
   $assert(this.isValid(), "isValid()", "leg/ssa/nodes.dart", 289, 12);
 }
 HInstruction.prototype.notifyRemovedFromBlock = function() {
   $assert(this.isInBasicBlock(), "isInBasicBlock()", "leg/ssa/nodes.dart", 293, 12);
   $assert(this.get$usedBy().isEmpty(), "usedBy.isEmpty()", "leg/ssa/nodes.dart", 294, 12);
@@ skipping 249 matching lines @@
   }
   return node;
 }
 // ********** Code for SsaDeadCodeEliminator **************
 function SsaDeadCodeEliminator() {
   HGraphVisitor.call(this);
   // Initializers done
 }
 $inherits(SsaDeadCodeEliminator, HGraphVisitor);
 SsaDeadCodeEliminator.isDeadCode = function(instruction) {
-  return !instruction.hasSideEffects() && instruction.get$usedBy().isEmpty();
+  return !$notnull_bool(instruction.hasSideEffects()) && instruction.get$usedBy().isEmpty();
 }
 SsaDeadCodeEliminator.prototype.visitGraph = function(graph) {
   this.visitPostDominatorTree(graph);
 }
 SsaDeadCodeEliminator.prototype.visitBasicBlock = function(block) {
   var instruction = block.last;
   while ($notnull_bool(instruction != null)) {
     var previous = instruction.previous;
     if ($notnull_bool(SsaDeadCodeEliminator.isDeadCode(instruction))) block.remove(instruction);
     instruction = (previous && previous.is$HInstruction());
@@ skipping 241 matching lines @@
   this.isValid = true
   HInstructionVisitor.call(this);
   // Initializers done
 }
 $inherits(HValidator, HInstructionVisitor);
 HValidator.prototype.visitGraph = function(graph0) {
   this.graph = graph0;
   this.visitDominatorTree(graph0);
 }
 HValidator.prototype.visitBasicBlock = function(block) {
-  if ($notnull_bool(!this.isValid)) return;
+  if ($notnull_bool(!$notnull_bool(this.isValid))) return;
   if ($notnull_bool(block.first == null || block.last == null)) this.isValid = false;
   if ($notnull_bool(!(block.last instanceof HGoto) && !(block.last instanceof HReturn) && !(block.last instanceof HExit))) {
     this.isValid = false;
   }
   if ($notnull_bool((block.last instanceof HGoto) && block.successors.length != 1)) this.isValid = false;
-  if ($notnull_bool((block.last instanceof HReturn) && (block.successors.length != 1 || !block.successors.$index(0).isExitBlock()))) {
+  if ($notnull_bool((block.last instanceof HReturn) && (block.successors.length != 1 || !$notnull_bool(block.successors.$index(0).isExitBlock())))) {
     this.isValid = false;
   }
-  if ($notnull_bool((block.last instanceof HExit) && !block.successors.isEmpty())) this.isValid = false;
+  if ($notnull_bool((block.last instanceof HExit) && !$notnull_bool(block.successors.isEmpty()))) this.isValid = false;
   if ($notnull_bool(block.successors.isEmpty() && (block.first !== block.last || !(block.last instanceof HExit)))) {
     this.isValid = false;
   }
-  if ($notnull_bool(!this.isValid)) return;
+  if ($notnull_bool(!$notnull_bool(this.isValid))) return;
   HInstructionVisitor.prototype.visitBasicBlock.call(this, block);
 }
 HValidator.countInstruction = function(instructions, instruction) {
   var result = 0;
   for (var i = 0;
    $notnull_bool(i < instructions.length); i++) {
     if ($notnull_bool(instructions.$index(i) === instruction)) result++;
   }
   return result;
 }
 HValidator.everyInstruction = function(instructions, f) {
   var copy = ListFactory.ListFactory$from$factory(instructions);
   for (var i = 0;
    $notnull_bool(i < copy.length); i++) {
     var current = copy.$index(i);
     if ($notnull_bool(current == null)) continue;
     var count = 1;
     for (var j = i + 1;
      $notnull_bool(j < copy.length); j++) {
       if ($notnull_bool(copy.$index(j) === current)) {
         copy.$setindex(j);
         count++;
       }
     }
-    if ($notnull_bool(!f.call$2(current, count))) return false;
+    if ($notnull_bool(!$notnull_bool(f.call$2(current, count)))) return false;
   }
   return true;
 }
 HValidator.prototype.visitInstruction = function(instruction) {
   var $this = this; // closure support
   function hasCorrectInputs(instruction0) {
     var inBasicBlock = instruction0.isInBasicBlock();
     return HValidator.everyInstruction(instruction0.inputs, (function (input, count) {
       if ($notnull_bool(inBasicBlock)) {
         return HValidator.countInstruction(input.get$usedBy(), (instruction0 && instruction0.is$HInstruction())) == count;
       }
       else {
         return HValidator.countInstruction(input.get$usedBy(), (instruction0 && instruction0.is$HInstruction())) == 0;
       }
     })
     );
   }
   function hasCorrectUses(instruction0) {
-    if ($notnull_bool(!instruction0.isInBasicBlock())) return true;
+    if ($notnull_bool(!$notnull_bool(instruction0.isInBasicBlock()))) return true;
     return HValidator.everyInstruction(instruction0.get$usedBy(), (function (use, count) {
       return HValidator.countInstruction(use.inputs, (instruction0 && instruction0.is$HInstruction())) == count;
     })
     );
   }
   this.isValid = $assert_bool(this.isValid && hasCorrectInputs(instruction) && hasCorrectUses(instruction));
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldCompiler **************
@@ skipping 72 matching lines @@
   if ($notnull_bool(false/*null.GENERATE_SSA_TRACE*/)) {
     print("------------------");
     print(HTracer.HTracer$singleton$factory());
     print("------------------");
   }
   this.log('compilation succeeded');
   return true;
 }
 Compiler.prototype.runCompiler = function() {
   this.scanner.scan(this.script);
-  while ($notnull_bool(!this.worklist.isEmpty())) {
+  while ($notnull_bool(!$notnull_bool(this.worklist.isEmpty()))) {
     var name = this.worklist.removeLast();
     var element = this.universe.find(name);
     if ($notnull_bool(element == null)) this.cancel(('Could not find ' + name + ''));
     var tree = element.parseNode(this, this);
     var elements = this.resolver.resolve(tree);
     this.checker.check(tree, elements);
     var graph = this.builder.build(tree);
     this.optimizer.optimize(graph);
     var code = this.generator.generate(tree, graph);
     this.universe.addGeneratedCode(element, code);
@@ skipping 84 matching lines @@
   this.context = this.context.parent;
   return element;
 }
 ResolverVisitor.prototype.visitBlock = function(node) {
   this.visitIn(node.statements, new Scope(this.context));
 }
 ResolverVisitor.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitFunctionExpression = function(node) {
-  if ($notnull_bool(!node.parameters.nodes.isEmpty())) this.fail(node);
+  if ($notnull_bool(!$notnull_bool(node.parameters.nodes.isEmpty()))) this.fail(node);
   var enclosingElement = this.visit(node.name);
   this.visitIn(node.body, new Scope.enclosing$ctor(this.context, enclosingElement));
   return enclosingElement;
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   var element = this.context.lookup(node.get$source());
   if ($notnull_bool(element == null)) this.fail(node);
   return element;
 }
 ResolverVisitor.prototype.visitIf = function(node) {
@@ skipping 31 matching lines @@
 }
 ResolverVisitor.prototype.visitLiteralBool = function(node) {
 
 }
 ResolverVisitor.prototype.visitLiteralString = function(node) {
 
 }
 ResolverVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 ResolverVisitor.prototype.visitOperator = function(node) {
   this.fail(node);
 }
 ResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
   return null;
 }
@@ skipping 23 matching lines @@
   this.resolver.visit((($0 = node.get$arguments().get$head()) && $0.is$Node()));
   this.visit(node.receiver);
 }
 VariableDefinitionsVisitor.prototype.visitIdentifier = function(node) {
   var variableElement = new Element(node.get$source(), this.resolver.context.enclosingElement);
   this.resolver.setElement(node, variableElement);
 }
 VariableDefinitionsVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 VariableDefinitionsVisitor.prototype.visit = function(node) {
   return node.accept(this);
 }
 // ********** Code for Scope **************
 function Scope(parent0) {
   Scope.enclosing$ctor.call(this, parent0, parent0.enclosingElement);
   // Initializers done
@@ skipping 42 matching lines @@
 $inherits(ScannerTask, CompilerTask);
 ScannerTask.prototype.get$name = function() {
   return 'Scanner';
 }
 ScannerTask.prototype.scan = function(script) {
   var $this = this; // closure support
   this.measure((function () {
     var $0;
     var elements = $this.scanElements(script.get$text());
     for (var link = elements;
-     $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
+     $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Element())) {
       $this.compiler.universe.define((($0 = link.get$head()) && $0.is$Element()));
     }
   })
   );
 }
 ScannerTask.prototype.scanElements = function(text) {
   var tokens = new StringScanner(text).tokenize();
   var listener = new Listener(this.compiler);
   var parser = new Parser(listener);
   parser.parseUnit(tokens);
@@ skipping 48 matching lines @@
   // Initializers done
 }
 FunctionType.prototype.is$Type = function(){return this;};
 FunctionType.prototype.get$returnType = function() { return this.returnType; };
 FunctionType.prototype.toString = function() {
   var $0;
   var sb = new StringBufferImpl("");
   var first = true;
   sb.add('(');
   for (var link = this.parameterTypes;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Type())) {
-    if ($notnull_bool(!first)) sb.add(', ');
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Type())) {
+    if ($notnull_bool(!$notnull_bool(first))) sb.add(', ');
     first = false;
     sb.add(link.get$head());
   }
   sb.add((') -> ' + this.returnType + ''));
   return sb.toString();
 }
 // ********** Code for Types **************
 function Types() {
   this.VOID = new SimpleType(const$254, new Element(const$254/*const SourceString('void')*/));
   this.INT = new SimpleType(const$255, new Element(const$255/*const SourceString('int')*/));
@@ skipping 46 matching lines @@
   if ($notnull_bool(node.get$hasElsePart())) this.visit(node.elsePart);
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var $0;
   var target = this.elements.$index(node);
   if ($notnull_bool(target != null)) {
     var funType = target.computeType(this.compiler, this.types);
     var formals = funType.parameterTypes;
     var arguments = node.get$arguments();
-    while ($notnull_bool((!formals.isEmpty()) && (!arguments.isEmpty()))) {
+    while ($notnull_bool((!$notnull_bool(formals.isEmpty())) && (!$notnull_bool(arguments.isEmpty())))) {
       this.compiler.cancel('parameters not supported.');
       var argumentType = this.visit((($0 = arguments.get$head()) && $0.is$Node()));
-      if ($notnull_bool(!this.types.isAssignable((($0 = formals.get$head()) && $0.is$Type()), (argumentType && argumentType.is$Type())))) {
+      if ($notnull_bool(!$notnull_bool(this.types.isAssignable((($0 = formals.get$head()) && $0.is$Type()), (argumentType && argumentType.is$Type()))))) {
         var warning = CompilerError.NOT_ASSIGNABLE((argumentType && argumentType.is$Type()), (($0 = formals.get$head()) && $0.is$Type()));
         this.compiler.reportWarning(node, warning);
       }
       formals = (($0 = formals.get$tail()) && $0.is$Link$Type());
       arguments = (($0 = arguments.get$tail()) && $0.is$Link$Node());
     }
-    if ($notnull_bool(!formals.isEmpty())) {
+    if ($notnull_bool(!$notnull_bool(formals.isEmpty()))) {
       this.compiler.reportWarning(node, 'missing argument');
     }
-    if ($notnull_bool(!arguments.isEmpty())) {
+    if ($notnull_bool(!$notnull_bool(arguments.isEmpty()))) {
       this.compiler.reportWarning(node, 'additional arguments');
     }
     return funType.returnType;
   }
   else {
     var selector = node.selector;
     var name = selector.get$source();
     if ($notnull_bool($eq(name, const$248/*const SourceString('print')*/) || $eq(name, const$249/*const SourceString('+')*/))) {
       return this.types.DYNAMIC;
     }
@@ skipping 11 matching lines @@
 }
 TypeCheckerVisitor.prototype.visitLiteralBool = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitLiteralString = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
-   $notnull_bool(!link.isEmpty()); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
+   $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.DYNAMIC;
 }
 TypeCheckerVisitor.prototype.visitParameter = function(node) {
   return null;
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expressionType = this.visit(node.expression);
-  if ($notnull_bool(!this.types.isAssignable(this.expectedReturnType, expressionType))) {
+  if ($notnull_bool(!$notnull_bool(this.types.isAssignable(this.expectedReturnType, expressionType)))) {
     var error = CompilerError.NOT_ASSIGNABLE(this.expectedReturnType, expressionType);
     this.compiler.reportWarning(node, error);
   }
   return this.types.VOID;
 }
 TypeCheckerVisitor.prototype.visitTypeAnnotation = function(node) {
   if ($notnull_bool(node.typeName != null && $ne(node.typeName.get$source(), const$254/*const SourceString('void')*/))) {
     this.compiler.cancel(('unsupported type ' + node.typeName + ''));
   }
   return this.types.VOID;
@@ skipping 65 matching lines @@
     this.write($assert_String(lines.$index(lines.length - 1)));
   }
   else {
     this._buf.add(text0);
   }
 }
 CodeWriter.prototype.writeln = function(text0) {
   if ($notnull_bool(text0 != null)) {
     this.write(text0);
   }
-  if ($notnull_bool(!text0.endsWith('\n'))) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
+  if ($notnull_bool(!$notnull_bool(text0.endsWith('\n')))) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
   this._pendingIndent = true;
 }
 CodeWriter.prototype.enterBlock = function(text0) {
   this.writeln(text0);
   this._indentation++;
 }
 CodeWriter.prototype.exitBlock = function(text0) {
   this._indentation--;
   this.writeln(text0);
 }
@@ skipping 22 matching lines @@
   var matchConstructor = world.get$coreimpl().types.$index('MatchImplementation').getConstructor('');
   this.genMethod((matchConstructor && matchConstructor.is$Member()));
   matchConstructor.generator.writeDefinition(this.writer, null);
   this.writeTypes(this.main.declaringType.get$library());
   this._writeDynamicStubs(world.functionType);
   this._writeGlobals();
   this.writer.writeln(('' + mainCall.code + ';'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
-  if ($notnull_bool(!this.globals.containsKey(fullname))) {
+  if ($notnull_bool(!$notnull_bool(this.globals.containsKey(fullname)))) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
   return this.globals.$index(fullname);
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var code = exp.canonicalCode;
-  if ($notnull_bool(!this.globals.containsKey(code))) {
+  if ($notnull_bool(!$notnull_bool(this.globals.containsKey(code)))) {
     this.globals.$setindex(code, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
   return this.globals.$index(code);
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
   if ($notnull_bool(lib.isWritten)) return;
   lib.isWritten = true;
   var $list = lib.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var import_ = $list.$index($i);
@@ skipping 24 matching lines @@
           this.writeType((ct && ct.is$lang_Type()));
         }
       }
     }
     if ($notnull_bool(type.typeCheckCode != null)) {
       this.writer.writeln(type.typeCheckCode);
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
-  if ($notnull_bool(!meth.isGenerated && !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(!checkType.isTested)) return;
+  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'))) {
     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() && !type.get$isTop())) {
+  if ($notnull_bool(type.get$isNativeType() && !$notnull_bool(type.get$isTop()))) {
     var nativeName = type.get$definition().nativeType;
     if ($notnull_bool($eq(nativeName, ''))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
     else if ($notnull_bool(type.get$jsname() != nativeName)) {
       this.writer.writeln(('' + type.get$jsname() + ' = ' + nativeName + ';'));
     }
   }
   if ($notnull_bool(type.get$isTop())) {
   }
   else if ($notnull_bool(type.constructors.get$length() == 0)) {
-    if ($notnull_bool(!type.get$isNativeType())) {
+    if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
       this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
     }
   }
   else {
     var standardConstructor = type.constructors.$index('');
     if ($notnull_bool(standardConstructor == null || standardConstructor.generator == null)) {
-      if ($notnull_bool(!type.get$isNativeType())) {
+      if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
     var $list = type.constructors.getValues();
     for (var $i = type.constructors.getValues().iterator(); $i.hasNext(); ) {
       var c = $i.next();
       if ($notnull_bool($ne(c.generator, null) && $ne(c, standardConstructor))) {
         c.generator.writeDefinition(this.writer, null);
       }
     }
   }
-  if ($notnull_bool(!type.get$isTop())) {
+  if ($notnull_bool(!$notnull_bool(type.get$isTop()))) {
     if ($notnull_bool((type instanceof ConcreteType))) {
       this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
     }
-    else if ($notnull_bool(!type.get$isNativeType())) {
-      if ($notnull_bool(type.get$parent() != null && !type.get$parent().get$isObject())) {
+    else if ($notnull_bool(!$notnull_bool(type.get$isNativeType()))) {
+      if ($notnull_bool(type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject()))) {
         this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$parent().get$jsname() + ');'));
       }
     }
   }
   if ($notnull_bool(!(type instanceof ConcreteType))) {
     this._maybeIsTest(type, type);
   }
   if ($notnull_bool(type.get$genericType()._concreteTypes != null)) {
     var $list = this._orderValues(type.get$genericType()._concreteTypes);
     for (var $i = 0;$i < $list.length; $i++) {
       var ct = $list.$index($i);
       this._maybeIsTest(type, (ct && ct.is$lang_Type()));
     }
   }
   if ($notnull_bool(type.get$interfaces() != null)) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
-    while ($notnull_bool(!worklist.isEmpty())) {
+    while ($notnull_bool(!$notnull_bool(worklist.isEmpty()))) {
       var interface_ = worklist.removeLast();
       this._maybeIsTest(type, interface_.get$genericType());
       if ($notnull_bool(interface_.get$genericType()._concreteTypes != null)) {
         var $list = this._orderValues(interface_.get$genericType()._concreteTypes);
         for (var $i = 0;$i < $list.length; $i++) {
           var ct = $list.$index($i);
           this._maybeIsTest(type, (ct && ct.is$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
       for (var $i = 0;$i < $list.length; $i++) {
         var other = $list.$index($i);
-        if ($notnull_bool(!seen.contains(other))) {
+        if ($notnull_bool(!$notnull_bool(seen.contains(other)))) {
           worklist.addLast(other);
           seen.add(other);
         }
       }
     }
   }
   type.factories.forEach$1(this.get$_writeMethod());
   var $list = this._orderValues((($0 = type.members) && $0.is$Map()));
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
@@ skipping 16 matching lines @@
       var stub = $list.$index($i);
       stub.generate(this.writer);
     }
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
   if ($notnull_bool(field.isFinal)) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
   if ($notnull_bool(this.globals.containsKey(fullname))) {
     var value = this.globals.$index(fullname);
-    if ($notnull_bool(field.declaringType.get$isTop() && !field.isNative)) {
+    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() && !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(!field.isFinal)) {
+    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) {
   if ($notnull_bool(property.getter != null)) this._writeMethod(property.getter);
   if ($notnull_bool(property.setter != null)) this._writeMethod(property.setter);
   if ($notnull_bool(property._provideFieldSyntax)) {
     this.writer.enterBlock('Object.defineProperty(' + ('' + property.declaringType.get$jsname() + '.prototype, "' + property.get$jsname() + '", {'));
     if ($notnull_bool(property.getter != null)) {
@@ skipping 70 matching lines @@
     this.reentrant = $assert_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
 BlockScope.prototype.get$isMethodScope = function() {
   return this.parent == null || $ne(this.parent.enclosingMethod, this.enclosingMethod);
 }
 BlockScope.prototype.get$methodScope = function() {
   var s = this;
-  while ($notnull_bool(!s.get$isMethodScope())) s = s.get$parent();
+  while ($notnull_bool(!$notnull_bool(s.get$isMethodScope()))) s = s.get$parent();
   return s;
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($notnull_bool($ne(ret, null))) return ret;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
     ret = s._vars.$index(name);
     if ($notnull_bool($ne(ret, null))) {
       if ($notnull_bool($ne(s.enclosingMethod, this.enclosingMethod))) {
@@ skipping 135 matching lines @@
     names = ListFactory.ListFactory$from$factory(this.captures);
     names.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     paramCode = ListFactory.ListFactory$from$factory((names && names.is$Iterable()));
     paramCode.addAll(this._paramCode);
   }
   var _params = ('(' + Strings.join(this._paramCode, ", ") + ')');
   var params = ('(' + Strings.join((paramCode && paramCode.is$List$String()), ", ") + ')');
-  if ($notnull_bool(this.method.declaringType.get$isTop() && !this.get$isClosure())) {
+  if ($notnull_bool(this.method.declaringType.get$isTop() && !$notnull_bool(this.get$isClosure()))) {
     defWriter.enterBlock(('function ' + this.method.get$jsname() + '' + params + ' {'));
   }
   else if ($notnull_bool(this.get$isClosure())) {
     if ($notnull_bool(this.method.name == '')) {
       defWriter.enterBlock(('(function ' + params + ' {'));
     }
     else if ($notnull_bool($ne(names, null))) {
       if ($notnull_bool(lambda == null)) {
         defWriter.enterBlock(('var ' + this.method.get$jsname() + ' = (function' + params + ' {'));
       }
@@ skipping 66 matching lines @@
     for (var $i = 0;$i < $list.length; $i++) {
       var param = $list.$index($i);
       if ($notnull_bool(param.get$isOptional())) {
         optNames.add(param.get$name());
         optValues.add(MethodGenerator._escapeString(param.get$value().code));
       }
     }
     if ($notnull_bool(optNames.length > 0)) {
       var start = '';
       if ($notnull_bool(this.method.get$isStatic())) {
-        if ($notnull_bool(!this.method.declaringType.get$isTop())) {
+        if ($notnull_bool(!$notnull_bool(this.method.declaringType.get$isTop()))) {
           start = this.method.declaringType.get$jsname() + '.';
         }
       }
       else {
         start = this.method.declaringType.get$jsname() + '.prototype.';
       }
       optNames.addAll(optValues);
       var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
       defWriter.writeln(('' + start + '' + this.method.get$jsname() + '.\$optional = ' + optional + ''));
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
   var $0;
   var initializers = null;
   var initializedFields = null;
   if ($notnull_bool(this.method.get$isConstructor())) {
     initializers = [];
     initializedFields = new HashSetImplementation();
     var $list = world.gen._orderValues(this.method.declaringType.getAllMembers());
     for (var $i = 0;$i < $list.length; $i++) {
       var f = $list.$index($i);
-      if ($notnull_bool((f instanceof FieldMember) && !f.get$isStatic())) {
+      if ($notnull_bool((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic()))) {
         var cv = f.computeValue();
         if ($notnull_bool($ne(cv, null))) {
           initializers.add(('this.' + f.get$jsname() + ' = ' + cv.code + ''));
           initializedFields.add(f.get$name());
         }
       }
     }
   }
   this._paramCode = [];
   var $list = this.method.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     if ($notnull_bool($ne(initializers, null) && p.get$name().startsWith('this.'))) {
       var name = p.get$name().substring(5);
       var field = this.method.declaringType.getMember(name);
       if ($notnull_bool(field == null)) {
         world.error('bad this parameter - no matching field', p.get$definition().get$span());
       }
-      if ($notnull_bool(!field.get$isField())) {
+      if ($notnull_bool(!$notnull_bool(field.get$isField()))) {
         world.error(('"' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
       var paramValue = new Value(field.get$returnType(), name, false, false, false);
       this._paramCode.add(paramValue.code);
       initializers.add(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
       initializedFields.add(name);
     }
     else {
       var paramValue = this._scope.create($assert_String(p.get$name()), (($0 = p.type) && $0.is$lang_Type()), (($0 = p.get$definition()) && $0.is$lang_Node()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
-  if ($notnull_bool(body == null && !this.method.get$isConstructor())) {
+  if ($notnull_bool(body == null && !$notnull_bool(this.method.get$isConstructor()))) {
     world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
   }
   if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator(); $i.hasNext(); ) {
       var i = $i.next();
       this.writer.writeln($assert_String(i));
     }
     var declaredInitializers = this.method.get$definition().initializers;
     if ($notnull_bool(declaredInitializers != null)) {
       var initializerCall = null;
       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(!((left instanceof DotExpression) && (left.self instanceof ThisExpression) || (left instanceof VarExpression)))) {
+          if ($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_$4(this, left.get$name().get$name(), left.get$name(), this.visitValue(init.y));
           this.writer.writeln(('' + assign.code + ';'));
         }
         else {
           world.error('invalid initializer', init.get$span());
         }
       }
       if ($notnull_bool($ne(initializerCall, null))) {
         var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
-        if ($notnull_bool(!target.isSuper)) {
+        if ($notnull_bool(!$notnull_bool(target.isSuper))) {
           if ($notnull_bool(initializers.length > 0)) {
             var $list = this.method.get$parameters();
             for (var $i = 0;$i < $list.length; $i++) {
               var p = $list.$index($i);
               if ($notnull_bool(p.get$name().startsWith('this.'))) {
                 world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
                 break;
               }
             }
           }
           if ($notnull_bool(declaredInitializers.length > 1)) {
             var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
             world.error('no initialization allowed on redirecting constructors', init.get$span());
           }
           initializedFields = null;
         }
       }
       else {
       }
     }
     this.writer.comment('// Initializers done');
   }
   if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.members.getKeys();
     for (var $i = this.method.declaringType.members.getKeys().iterator(); $i.hasNext(); ) {
       var name = $i.next();
       var member = this.method.declaringType.members.$index(name);
-      if ($notnull_bool((member instanceof FieldMember) && member.isFinal && !member.get$isStatic() && !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 316 matching lines @@
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
     var ex = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
     this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
     if ($notnull_bool(catch_.trace != null)) {
       var trace = this._scope.declare(catch_.trace);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
     }
     this._genToDartException(ex.code);
-    if ($notnull_bool(!ex.type.get$isVar())) {
+    if ($notnull_bool(!$notnull_bool(ex.type.get$isVar()))) {
       var test = ex.instanceOf(this, (($0 = ex.type) && $0.is$lang_Type()), catch_.get$exception().get$span(), false, true);
       this.writer.writeln(('if (' + test.code + ') throw ' + ex.code + ';'));
     }
     this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$lang_Statement()));
     this._popBlock();
   }
   else if ($notnull_bool(node.catches.length > 0)) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', world.varType, null);
     this._scope.rethrow = (ex && ex.is$Value());
     this.writer.nextBlock(('} catch (' + ex.code + ') {'));
     var trace = null;
     if ($notnull_bool(node.catches.some((function (c) {
       return c.trace != null;
     })
     ))) {
       trace = this._scope.create('\$trace', world.varType, null);
       this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
     }
     this._genToDartException(ex.code);
     var needsRethrow = true;
     for (var i = 0;
      $notnull_bool(i < node.catches.length); i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
       var tmp = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
-      if ($notnull_bool(!tmp.type.get$isVar())) {
+      if ($notnull_bool(!$notnull_bool(tmp.type.get$isVar()))) {
         var test = ex.instanceOf(this, (($0 = tmp.type) && $0.is$lang_Type()), catch_.get$exception().get$span(), true, true);
         if ($notnull_bool(i == 0)) {
           this.writer.enterBlock(('if (' + test.code + ') {'));
         }
         else {
           this.writer.nextBlock(('} else if (' + test.code + ') {'));
         }
       }
       else if ($notnull_bool(i > 0)) {
         this.writer.nextBlock('} else {');
@@ skipping 51 matching lines @@
         }
         this.writer.writeln('default:');
       }
       else {
         var value = this.visitValue((expr && expr.is$lang_Expression()));
         this.writer.writeln(('case ' + value.code + ':'));
       }
     }
     this.writer.enterBlock('');
     var caseExits = this._visitAllStatements(case_.statements, false);
-    if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1)) && !caseExits)) {
+    if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1)) && !$notnull_bool(caseExits))) {
       var span = case_.statements.$index(case_.statements.length - 1).get$span();
       this.writer.writeln('\$throw(new FallThroughError());');
     }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
@@ skipping 36 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', true, true, false);
+  return new Value(parentType, 'this', true, false, false);
 }
 MethodGenerator.prototype._getOutermostMethod = function() {
   var result = this;
   while ($notnull_bool(result.enclosingMethod != null)) {
     result = result.enclosingMethod;
   }
   return result;
 }
 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', false, true, false);
+    return new Value(outermostMethod.method.declaringType, '\$this', false, false, false);
   }
   else {
     this._checkNonStatic(node);
-    return new Value(this.method.declaringType, 'this', false, true, false);
+    return new Value(this.method.declaringType, 'this', false, false, 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);
@@ skipping 107 matching lines @@
       x = this._makeThisOrType();
     }
     else {
       var member = this.method.declaringType.get$library().lookup(xn.name.name, xn.name.span);
       if ($notnull_bool(member == null)) {
         world.warning(('can not resolve ' + xn.name.name + ''), xn.span);
         return this._makeMissingValue(xn.name.name);
       }
       members = new MemberSet(member);
     }
-    if ($notnull_bool(!members.get$treatAsField() || members.get$containsMethods())) {
+    if ($notnull_bool(!$notnull_bool(members.get$treatAsField()) || members.get$containsMethods())) {
       if ($notnull_bool(kind != 0)) {
         var right = members.get_$3(this, position, x);
         right = captureOriginal((right && right.is$Value()));
         y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
       }
       return members.set_$4(this, position, x, y);
     }
     x = members.get_$3(this, position, x);
   }
   y = y.convertTo(this, (($0 = x.type) && $0.is$lang_Type()), yn, false);
@@ skipping 15 matching lines @@
 }
 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()));
     tmpindex = this.getTemp((index && index.is$Value()));
-    var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [this.assignTemp((tmpindex && tmpindex.is$Value()), (index && index.is$Value()))]));
+    index = this.assignTemp((tmpindex && tmpindex.is$Value()), (index && index.is$Value()));
+    var right = tmptarget.invoke$4(this, '\$index', position, new Arguments(null, [tmpindex]));
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
   }
   var ret = this.assignTemp((tmptarget && tmptarget.is$Value()), (target && target.is$Value())).invoke(this, '\$setindex', position, new Arguments(null, [index, y]), false);
   if ($notnull_bool($ne(tmptarget, target))) this.freeTemp((tmptarget && tmptarget.is$Value()));
   if ($notnull_bool($ne(tmpindex, index))) this.freeTemp((tmpindex && tmpindex.is$Value()));
   return ret;
 }
 MethodGenerator.prototype._visitDotAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = xn.self.visit(this);
@@ skipping 20 matching lines @@
       }
       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 = !value.get$actualValue();
+        var newVal = !$notnull_bool(value.get$actualValue());
         return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
       }
       else {
-        return new Value(world.boolType, ('!' + value.code + ''), false, true, false);
+        var newVal = value.convertToNonNullBool(this, node);
+        return new Value(world.boolType, ('!' + newVal.code + ''), false, true, false);
       }
 
     case 42/*TokenKind.ADD*/:
+
+      return value.convertTo(this, world.numType, node, false);
+
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
-      if ($notnull_bool(value.type.get$isNum())) {
-        if ($notnull_bool(value.get$isConst())) {
-          if ($notnull_bool(node.op.kind == 42/*TokenKind.ADD*/)) {
-            return value;
-          }
-          else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) {
-            var newVal = $negate(value.get$actualValue());
-            return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
-          }
-          else {
-            var newVal = (~value.get$actualValue().toInt()).toDouble();
-            return EvaluatedValue.EvaluatedValue$factory(value.type, newVal, ('' + newVal + ''), node.span);
-          }
-        }
-        return new Value(value.type, ('' + node.op + '' + value.code + ''), false, true, false);
+      if ($notnull_bool(node.op.kind == 18/*TokenKind.BIT_NOT*/)) {
+        return value.invoke$4(this, '\$bit_not', node, Arguments.get$EMPTY());
+      }
+      else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) {
+        return value.invoke$4(this, '\$negate', node, Arguments.get$EMPTY());
       }
       else {
-        var name;
-        if ($notnull_bool(node.op.kind == 18/*TokenKind.BIT_NOT*/)) name = '\$bit_not';
-        else if ($notnull_bool(node.op.kind == 43/*TokenKind.SUB*/)) name = '\$negate';
-        else world.internalError(('unimplemented: unary ' + node.op + ' on var'), node.span);
-        return new Value(world.varType, ('' + name + '(' + value.code + ')'), false, true, false);
+        world.internalError(('unimplemented: unary ' + node.op + ''), node.span);
       }
+      $throw(new FallThroughError());
 
     default:
 
       world.internalError(('unimplemented: ' + node.op + ''), node.span);
 
   }
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
@@ skipping 43 matching lines @@
   var m = type.getConstructor(constructorName);
   if ($notnull_bool(m == null)) {
     var name = type.get$jsname();
     if ($notnull_bool(type.get$isVar())) {
       name = typeRef.get$name().get$name();
     }
     world.error(('no matching constructor for ' + name + ''), node.span);
     return this._makeMissingValue($assert_String(name));
   }
   if ($notnull_bool(node.isConst)) {
-    if ($notnull_bool(!m.get$isConst())) {
+    if ($notnull_bool(!$notnull_bool(m.get$isConst()))) {
       world.error('can\'t use const on a non-const constructor', node.span);
     }
     var $list = node.arguments;
     for (var $i = 0;$i < $list.length; $i++) {
       var arg = $list.$index($i);
-      if ($notnull_bool(!this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())).get$isConst())) {
+      if ($notnull_bool(!$notnull_bool(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())).get$isConst()))) {
         world.error('const constructor expects const arguments', arg.get$span());
       }
     }
   }
   return m.invoke$4(this, node, null, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argsCode = [];
   var argValues = [];
   var $list = node.values;
   for (var $i = 0;$i < $list.length; $i++) {
     var item = $list.$index($i);
     var arg = this.visitValue((item && item.is$lang_Expression()));
     argValues.add(arg);
     if ($notnull_bool(node.isConst)) {
-      if ($notnull_bool(!arg.get$isConst())) {
+      if ($notnull_bool(!$notnull_bool(arg.get$isConst()))) {
         world.error('const list can only contain const values', item.get$span());
         argsCode.add(arg.code);
       }
       else {
         argsCode.add(arg.canonicalCode);
       }
     }
     else {
       argsCode.add(arg.code);
     }
@@ skipping 15 matching lines @@
   var argValues = [];
   var argsCode = [];
   for (var i = 0;
    $notnull_bool(i < node.items.length); i += 2) {
     var key = this.visitTypedValue((($0 = node.items.$index(i)) && $0.is$lang_Expression()), world.stringType);
     var valueItem = node.items.$index(i + 1);
     var value = this.visitValue((valueItem && valueItem.is$lang_Expression()));
     argValues.add(key);
     argValues.add(value);
     if ($notnull_bool(node.isConst)) {
-      if ($notnull_bool(!key.get$isConst() || !value.get$isConst())) {
+      if ($notnull_bool(!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst()))) {
         world.error('const map can only contain const values', valueItem.get$span());
         argsCode.add(key.code);
         argsCode.add(value.code);
       }
       else {
         argsCode.add(key.canonicalCode);
         argsCode.add(value.canonicalCode);
       }
     }
     else {
@@ skipping 71 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(null, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2019, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2011, 12);
   if ($notnull_bool(!!(($0 = node.value) && $0.is$List))) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
         code = ('(' + code + ')');
@@ skipping 239 matching lines @@
   }
   return this.types.$index(name0);
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if ($notnull_bool(result == null)) return null;
   if ($notnull_bool(type.names != null)) {
     if ($notnull_bool(type.names.length > 1)) {
       return null;
     }
-    if ($notnull_bool(!result.get$isTop())) {
+    if ($notnull_bool(!$notnull_bool(result.get$isTop()))) {
       return null;
     }
     return result.get$library().findTypeByName($assert_String(type.names.$index(0).get$name()));
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name0) {
   var ret = this.types.$index(name0);
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 124 matching lines @@
   $assert(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(!this.isTop)) {
+  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);
@@ skipping 91 matching lines @@
   if ($notnull_bool(args.length > 1)) {
     world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
   }
   for (var $i = args.iterator(); $i.hasNext(); ) {
     var arg = $i.next();
     return this._parseStringArgument((arg && arg.is$ArgumentNode()));
   }
 }
 _LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
-  if ($notnull_bool(!(expr instanceof LiteralExpression) || !expr.type.type.get$isString())) {
+  if ($notnull_bool(!(expr instanceof LiteralExpression) || !$notnull_bool(expr.type.type.get$isString()))) {
     world.error('expected string', expr.get$span());
   }
   return parseStringLiteral($assert_String(expr.get$value()));
 }
 _LibraryVisitor.prototype.visitTypeDefinition = function(node) {
   var oldType = this.currentType;
   this.currentType = this.library.addType(node.name.name, node, node.isClass);
   var $list = node.body;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
@@ skipping 221 matching lines @@
 }
 $inherits(FieldMember, Member);
 FieldMember.prototype.is$FieldMember = function(){return this;};
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
 FieldMember.prototype.set$isNative = function(value) { return this.isNative = value; };
 FieldMember.prototype.override = function(other) {
-  if ($notnull_bool(!Member.prototype.override.call(this, other))) return false;
+  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
   if ($notnull_bool(other.get$isProperty())) {
     return true;
   }
   else {
     world.error('field can not override anything but property', this.get$span(), other.get$span());
     return false;
   }
 }
 FieldMember.prototype.get$prefersPropertySyntax = function() {
   return false;
@@ skipping 10 matching lines @@
 FieldMember.prototype.get$span = function() {
   return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 FieldMember.prototype.get$returnType = function() {
   return this.type;
 }
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
-  return !this.isFinal;
+  return !$notnull_bool(this.isFinal);
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function(inType) {
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if ($notnull_bool(this.definition.modifiers != null)) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
@@ skipping 30 matching lines @@
   if ($notnull_bool(this._computedValue == null)) {
     if ($notnull_bool(this._computing)) {
       world.error('circular reference', this.value.span);
       return null;
     }
     this._computing = true;
     var finalMethod = new MethodMember('final_context', this.declaringType, null);
     finalMethod.isStatic = true;
     var finalGen = new MethodGenerator(finalMethod, null);
     this._computedValue = (($0 = this.value.visit(finalGen)) && $0.is$Value());
-    if ($notnull_bool(!this._computedValue.get$isConst())) {
+    if ($notnull_bool(!$notnull_bool(this._computedValue.get$isConst()))) {
       if ($notnull_bool(this.isStatic)) {
         world.error('non constant static field must be initialized in functions', this.value.span);
       }
       else {
         world.error('non constant field must be initialized in constructor', this.value.span);
       }
     }
     if ($notnull_bool(this.isStatic)) {
       this._computedValue = world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
     }
     this._computing = false;
   }
   return this._computedValue;
 }
 FieldMember.prototype.get_ = function(context, node, target, isDynamic) {
-  if ($notnull_bool(!isDynamic)) {
+  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;
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), false, true, false);
     }
@@ skipping 57 matching lines @@
 PropertyMember.prototype.get$isStatic = function() {
   return $notnull_bool(this.getter == null) ? this.setter.isStatic : this.getter.isStatic;
 }
 PropertyMember.prototype.get$isProperty = function() {
   return true;
 }
 PropertyMember.prototype.get$returnType = function() {
   return $notnull_bool(this.getter == null) ? this.setter.returnType : this.getter.returnType;
 }
 PropertyMember.prototype.override = function(other) {
-  if ($notnull_bool(!Member.prototype.override.call(this, other))) return false;
+  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
   if ($notnull_bool(other.get$isProperty() || other.get$isField())) {
     if ($notnull_bool(other.get$isProperty())) this.addFromParent(other);
     return true;
   }
   else {
     world.error('property can only override field or property', this.get$span(), other.get$span());
     return false;
   }
 }
 PropertyMember.prototype.get_ = function(context, node, target, isDynamic) {
@@ skipping 180 matching lines @@
 MethodMember.prototype.get$isConst = function() { return this.isConst; };
 MethodMember.prototype.set$isConst = function(value) { return this.isConst = value; };
 MethodMember.prototype.get$isFactory = function() { return this.isFactory; };
 MethodMember.prototype.set$isFactory = function(value) { return this.isFactory = value; };
 MethodMember.prototype.get$initDelegate = function() { return this.initDelegate; };
 MethodMember.prototype.set$initDelegate = function(value) { return this.initDelegate = value; };
 MethodMember.prototype.get$isConstructor = function() {
   return this.name == this.declaringType.name;
 }
 MethodMember.prototype.get$isMethod = function() {
-  return !this.get$isConstructor();
+  return !$notnull_bool(this.get$isConstructor());
 }
 MethodMember.prototype.get$isNative = function() {
   return (this.definition.body instanceof NativeStatement);
 }
 MethodMember.prototype.get$canGet = function() {
   return false;
 }
 MethodMember.prototype.get$canSet = function() {
   return false;
 }
@@ skipping 13 matching lines @@
 MethodMember.prototype.get$functionType = function() {
   if ($notnull_bool(this._functionType == null)) {
     this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
     if ($notnull_bool(this.parameters == null)) {
       this.resolve(this.declaringType);
     }
   }
   return this._functionType;
 }
 MethodMember.prototype.override = function(other) {
-  if ($notnull_bool(!Member.prototype.override.call(this, other))) return false;
+  if ($notnull_bool(!$notnull_bool(Member.prototype.override.call(this, other)))) return false;
   if ($notnull_bool(other.get$isMethod())) {
     return true;
   }
   else {
     world.error('method can only override methods', this.get$span(), other.get$span());
     return false;
   }
 }
 MethodMember.prototype.canInvoke = function(context, args) {
   var bareCount = args.get$bareCount();
   if ($notnull_bool(bareCount > this.parameters.length)) return false;
   if ($notnull_bool(bareCount == this.parameters.length)) {
     if ($notnull_bool(bareCount != args.get$length())) return false;
   }
   else {
-    if ($notnull_bool(!this.parameters.$index(bareCount).get$isOptional())) return false;
+    if ($notnull_bool(!$notnull_bool(this.parameters.$index(bareCount).get$isOptional()))) return false;
     for (var i = bareCount;
      $notnull_bool(i < args.get$length()); i++) {
       if ($notnull_bool(this.indexOfParameter(args.getName(i)) < 0)) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember.prototype.indexOfParameter = function(name0) {
@@ skipping 32 matching lines @@
   this.declaringType.genMethod(this);
   this._provideOptionalParamInfo = true;
   if ($notnull_bool(this.isStatic)) {
     var type = $notnull_bool(this.declaringType.get$isTop()) ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), false, true, false);
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), false, true, false);
 }
 MethodMember.prototype.namesInOrder = function(args) {
-  if ($notnull_bool(!args.get$hasNames())) return true;
+  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;
       }
       lastParameter = $assert_num(p);
     }
@@ skipping 44 matching lines @@
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   var $0;
   if ($notnull_bool(this.parameters == null)) {
     world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name + ''));
     this.resolve(this.declaringType);
   }
   this.declaringType.genMethod(this);
   if ($notnull_bool(this.isStatic || this.isFactory)) {
     this.declaringType.markUsed();
   }
-  if ($notnull_bool(!this.namesInOrder(args))) {
+  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))) {
     argsCode.add('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
    $notnull_bool(i < bareCount); i++) {
     var arg = args.values.$index(i);
@@ skipping 15 matching lines @@
     for (var i = bareCount;
      $notnull_bool(i < this.parameters.length); i++) {
       var arg = args.getValue($assert_String(this.parameters.$index(i).get$name()));
       if ($notnull_bool(arg == null)) {
         arg = this.parameters.$index(i).get$value();
       }
       else {
         arg = arg.convertTo(context, (($0 = this.parameters.$index(i).type) && $0.is$lang_Type()), node, isDynamic);
         namedArgsUsed++;
       }
-      if ($notnull_bool(arg == null || !this.parameters.$index(i).get$isOptional())) {
+      if ($notnull_bool(arg == null || !$notnull_bool(this.parameters.$index(i).get$isOptional()))) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
         argsCode.add($notnull_bool(this.isConst && arg.get$isConst()) ? arg.canonicalCode : arg.code);
       }
     }
     if ($notnull_bool(namedArgsUsed < args.get$nameCount())) {
       var seen = new HashSetImplementation$String();
       for (var i = bareCount;
@@ skipping 12 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 + ')'), false, true, false);
+  }
   if ($notnull_bool(this.name.startsWith('\$'))) {
     return this._invokeBuiltin(context, node, target, args, argsCode);
   }
-  if ($notnull_bool(target != null && target.isSuper)) {
-    return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.prototype.' + this.get$jsname() + '.call(' + argsString + ')'), false, true, false);
-  }
   if ($notnull_bool(this.isFactory)) {
     return new Value(this.returnType, ('' + this.get$generatedFactoryName() + '(' + argsString + ')'), false, true, false);
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.returnType, ('' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
     }
     return new Value(this.returnType, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
@@ skipping 92 matching lines @@
         var fname = init.x.get$name().get$name();
         var val = this.generator.visitValue(init.y);
         fields.$setindex(fname, val);
       }
     }
     this.generator._popBlock();
   }
   var $list = this.declaringType.members.getValues();
   for (var $i = this.declaringType.members.getValues().iterator(); $i.hasNext(); ) {
     var f = $i.next();
-    if ($notnull_bool((f instanceof FieldMember) && !f.get$isStatic() && $ne(f.get$value(), null) && !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) {
     return arg.get$isConst();
   })
   );
   if ($notnull_bool(this.declaringType.get$isNum())) {
-    if ($notnull_bool(!allConst)) {
+    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')) {
         code = ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')');
       }
@@ skipping 161 matching lines @@
     }
     else if ($notnull_bool(target.type.get$isNum() || target.type.get$isString())) {
       return new Value(this.returnType, ('' + target.code + ' ' + op + ' ' + argsCode.$index(0) + ''), false, true, false);
     }
     return new Value(this.returnType, ('' + this.name + '(' + target.code + ', ' + argsCode.$index(0) + ')'), false, true, false);
   }
   if ($notnull_bool(this.name == '\$call')) {
     this.declaringType.markUsed();
     return new Value(this.returnType, ('' + target.code + '(' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ')'), false, true, false);
   }
-  return target.invokeSpecial(this.get$jsname(), args, this.returnType);
+  var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
+  return new Value(this.returnType, ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), false, true, false);
 }
 MethodMember.prototype.resolve = function(inType) {
   this.isStatic = inType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
-  this.isAbstract = !this.declaringType.get$isClass();
+  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);
       if ($notnull_bool(mod.kind == 86/*TokenKind.STATIC*/)) {
         if ($notnull_bool(this.isStatic)) {
           world.error('duplicate static modifier', mod.get$span());
         }
         this.isStatic = true;
       }
@@ skipping 21 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)) {
+    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.definition.body.span);
+      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.definition.span);
+      world.error('static method can not be abstract', this.get$span());
     }
   }
   else {
-    if ($notnull_bool(this.definition.body == null && !this.get$isConstructor())) {
+    if ($notnull_bool(this.definition.body == null && !$notnull_bool(this.get$isConstructor()))) {
       world.error('method needs a body', this.get$span());
     }
   }
   if ($notnull_bool(this.get$isConstructor())) {
     this.returnType = this.declaringType;
   }
   else {
     this.returnType = inType.resolveType(this.definition.returnType, false);
     if ($notnull_bool(this.isStatic && this.returnType.get$hasTypeParams())) {
       world.error('using type parameter in static context', this.definition.returnType.span);
     }
   }
   this.parameters = [];
   var $list = this.definition.formals;
   for (var $i = 0;$i < $list.length; $i++) {
     var formal = $list.$index($i);
     var param = new lang_Parameter(formal);
     param.resolve(this, inType);
     this.parameters.add(param);
   }
-  if ($notnull_bool(!this.isLambda)) {
+  if ($notnull_bool(!$notnull_bool(this.isLambda))) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.get_$3 = function($0, $1, $2) {
   return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()), false);
 }
@@ skipping 26 matching lines @@
 MemberSet.prototype.get$isStatic = function() {
   return 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(!target.type.get$isVar())) {
+  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 + '*/'), false, true, false);
 }
 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);
@@ skipping 372 matching lines @@
   }
 }
 TokenizerBase.prototype._finishToken = function(kind) {
   return new lang_Token(kind, this._source, this._startIndex, this._lang_index);
 }
 TokenizerBase.prototype._errorToken = function() {
   return this._finishToken(65/*TokenKind.ERROR*/);
 }
 TokenizerBase.prototype.finishWhitespace = function() {
   while ($notnull_bool(this._lang_index < this._text.length)) {
-    if ($notnull_bool(!TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++)))) {
+    if ($notnull_bool(!$notnull_bool(TokenizerHelpers.isWhitespace(this._text.charCodeAt(this._lang_index++))))) {
       this._lang_index--;
       return this.next();
     }
   }
   return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 }
 TokenizerBase.prototype.finishHashBang = function() {
   while ($notnull_bool(true)) {
     var ch = this._nextChar();
     if ($notnull_bool(ch == 0 || ch == 10 || ch == 13)) {
@@ skipping 103 matching lines @@
         if ($notnull_bool(this._maybeEatChar(quote))) {
           return this._finishToken(58/*TokenKind.STRING*/);
         }
       }
     }
     else if ($notnull_bool(ch == 36)) {
       this._interpStack = InterpStack.push(this._interpStack, quote, true);
       return this._finishToken(66/*TokenKind.INCOMPLETE_STRING*/);
     }
     else if ($notnull_bool(ch == 92)) {
-      if ($notnull_bool(!this.eatEscapeSequence())) {
+      if ($notnull_bool(!$notnull_bool(this.eatEscapeSequence()))) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype._finishOpenBrace = function() {
   var $0;
   if ($notnull_bool(this._interpStack != null)) {
     if ($notnull_bool(this._interpStack.depth == -1)) {
       this._interpStack.depth = 1;
@@ skipping 62 matching lines @@
       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(!this.eatEscapeSequence())) {
+      if ($notnull_bool(!$notnull_bool(this.eatEscapeSequence()))) {
         return this._errorToken();
       }
     }
   }
 }
 TokenizerBase.prototype.eatEscapeSequence = function() {
   var hex;
   switch (this._nextChar()) {
     case 120:
 
@@ skipping 35 matching lines @@
   if ($notnull_bool(TokenizerHelpers.isDigit(this._peekChar()))) {
     this.eatDigits();
     return this.finishNumberExtra(62/*TokenKind.DOUBLE*/);
   }
   else {
     return this._finishToken(14/*TokenKind.DOT*/);
   }
 }
 TokenizerBase.prototype.finishIdentifier = function() {
   while ($notnull_bool(this._lang_index < this._text.length)) {
-    if ($notnull_bool(!TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++)))) {
+    if ($notnull_bool(!$notnull_bool(TokenizerHelpers.isIdentifierPart(this._text.charCodeAt(this._lang_index++))))) {
       this._lang_index--;
       break;
     }
   }
   var kind = this.getIdentifierKind();
   if ($notnull_bool(this._interpStack != null && this._interpStack.depth == -1)) {
     this._interpStack.depth = 0;
   }
   if ($notnull_bool(kind == 70/*TokenKind.IDENTIFIER*/)) {
     return this._finishToken(70/*TokenKind.IDENTIFIER*/);
@@ skipping 1388 matching lines @@
   if ($notnull_bool(this._peekToken.kind == kind)) {
     this._previousToken = this._peekToken;
     this._peekToken = this.tokenizer.next();
     return true;
   }
   else {
     return false;
   }
 }
 lang_Parser.prototype._eat = function(kind) {
-  if ($notnull_bool(!this._maybeEat(kind))) {
+  if ($notnull_bool(!$notnull_bool(this._maybeEat(kind)))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 lang_Parser.prototype._eatSemicolon = function() {
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 lang_Parser.prototype._errorExpected = function(expected) {
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
   this._lang_error($assert_String(message), tok.get$span());
@@ skipping 24 matching lines @@
 }
 lang_Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
   while ($notnull_bool(this._peekKind(12/*TokenKind.HASH*/))) {
     ret.add(this.directive());
   }
-  while ($notnull_bool(!this._maybeEat(1/*TokenKind.END_OF_FILE*/))) {
+  while ($notnull_bool(!$notnull_bool(this._maybeEat(1/*TokenKind.END_OF_FILE*/)))) {
     ret.add(this.topLevelDefinition());
   }
   return ret;
 }
 lang_Parser.prototype.directive = function() {
   var start = this._peekToken.start;
   this._eat(12/*TokenKind.HASH*/);
   var name = this.identifier();
   var args = this.arguments();
   this._eatSemicolon();
@@ skipping 38 matching lines @@
   var _native = null;
   if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
     _native = this.maybeStringLiteral();
   }
   var _factory = null;
   if ($notnull_bool(this._maybeEat(75/*TokenKind.FACTORY*/))) {
     _factory = this.type(0);
   }
   var body = [];
   if ($notnull_bool(this._maybeEat(6/*TokenKind.LBRACE*/))) {
-    while ($notnull_bool(!this._maybeEat(7/*TokenKind.RBRACE*/))) {
+    while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
       if ($notnull_bool(this.isPrematureEndOfFile())) break;
       body.add(this.declaration(true));
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
   return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
 }
 lang_Parser.prototype.functionTypeAlias = function() {
@@ skipping 16 matching lines @@
     ret.add(this.expression());
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   this._inInitializers = false;
   return ret;
 }
 lang_Parser.prototype.functionBody = function(inExpression) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._maybeEat(9/*TokenKind.ARROW*/))) {
     var expr = this.expression();
-    if ($notnull_bool(!inExpression)) {
+    if ($notnull_bool(!$notnull_bool(inExpression))) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
     if ($notnull_bool(this.diet)) {
       this._skipBlock();
       return new DietStatement(this._makeSpan(start));
     }
     else {
       return this.block();
     }
   }
-  else if ($notnull_bool(!inExpression)) {
+  else if ($notnull_bool(!$notnull_bool(inExpression))) {
     if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
       return null;
     }
     else if ($notnull_bool(this._maybeEat(81/*TokenKind.NATIVE*/))) {
       var nativeBody = this.maybeStringLiteral();
       if ($notnull_bool(this._peekKind(10/*TokenKind.SEMICOLON*/))) {
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
@@ skipping 204 matching lines @@
 lang_Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return ret;
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
   this._eat(6/*TokenKind.LBRACE*/);
   var stmts = [];
-  while ($notnull_bool(!this._maybeEat(7/*TokenKind.RBRACE*/))) {
+  while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add(this.statement());
   }
   return new BlockStatement(stmts, this._makeSpan(start));
 }
 lang_Parser.prototype.emptyStatement = function() {
   var start = this._peekToken.start;
   this._eat(10/*TokenKind.SEMICOLON*/);
   return new EmptyStatement(this._makeSpan(start));
 }
@@ skipping 26 matching lines @@
 }
 lang_Parser.prototype.forStatement = function() {
   var start = this._peekToken.start;
   this._eat(99/*TokenKind.FOR*/);
   this._eat(2/*TokenKind.LPAREN*/);
   var init = this.forInitializerStatement(start);
   if ($notnull_bool((init instanceof ForInStatement))) {
     return init;
   }
   var test = null;
-  if ($notnull_bool(!this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
+  if ($notnull_bool(!$notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/)))) {
     test = this.expression();
     this._eatSemicolon();
   }
   var step = [];
-  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
+  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
     step.add(this.expression());
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       step.add(this.expression());
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   var body = this.statement();
   return new ForStatement(init, test, step, body, this._makeSpan(start));
 }
 lang_Parser.prototype.forInitializerStatement = function(start) {
@@ skipping 51 matching lines @@
   this._eat(3/*TokenKind.RPAREN*/);
   var body = this.block();
   return new CatchNode(exc, trace, body, this._makeSpan(start));
 }
 lang_Parser.prototype.switchStatement = function() {
   var start = this._peekToken.start;
   this._eat(107/*TokenKind.SWITCH*/);
   var test = this.testCondition();
   var cases = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while ($notnull_bool(!this._maybeEat(7/*TokenKind.RBRACE*/))) {
+  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*/);
 }
 lang_Parser.prototype.caseNode = function() {
   var start = this._peekToken.start;
@@ skipping 13 matching lines @@
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
   if ($notnull_bool(cases.length == 0)) {
     this._lang_error('case or default');
   }
   var stmts = [];
-  while ($notnull_bool(!this._peekCaseEnd())) {
+  while ($notnull_bool(!$notnull_bool(this._peekCaseEnd()))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
 lang_Parser.prototype.returnStatement = function() {
   var start = this._peekToken.start;
   this._eat(105/*TokenKind.RETURN*/);
   var expr;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
@@ skipping 110 matching lines @@
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if ($notnull_bool(prec >= precedence)) {
       if ($notnull_bool(kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/)) {
         if ($notnull_bool(this._isBin(x, 52/*TokenKind.LT*/))) {
           return this._fixAsType((x && x.is$BinaryExpression()));
         }
       }
       var op = this._lang_next();
       if ($notnull_bool(op.kind == 102/*TokenKind.IS*/)) {
-        var isTrue = !this._maybeEat(19/*TokenKind.NOT*/);
+        var isTrue = !$notnull_bool(this._maybeEat(19/*TokenKind.NOT*/));
         var typeRef = this.type(0);
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
       var y = this.infixExpression($assert_num($notnull_bool($eq(prec, 2)) ? prec : prec + 1));
       if ($notnull_bool(op.kind == 33/*TokenKind.CONDITIONAL*/)) {
         this._eat(8/*TokenKind.COLON*/);
         var z = this.infixExpression($assert_num(prec + 1));
         x = new ConditionalExpression(x, y, z, this._makeSpan(x.span.start));
       }
@@ skipping 43 matching lines @@
   expr = this.expression();
   if ($notnull_bool(label == null && this._maybeEat(8/*TokenKind.COLON*/))) {
     label = this._makeLabel(expr);
     expr = this.expression();
   }
   return new ArgumentNode(label, expr, this._makeSpan(start));
 }
 lang_Parser.prototype.arguments = function() {
   var args = [];
   this._eat(2/*TokenKind.LPAREN*/);
-  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
+  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
     do {
       args.add(this.argument());
     }
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return args;
 }
 lang_Parser.prototype.get$arguments = function() {
   return lang_Parser.prototype.arguments.bind(this);
@@ skipping 147 matching lines @@
       return this.finishTypedLiteral(start, false);
 
     case 113/*TokenKind.VOID*/:
     case 112/*TokenKind.VAR*/:
     case 97/*TokenKind.FINAL*/:
 
       return this.declaredIdentifier(false);
 
     default:
 
-      if ($notnull_bool(!this._peekIdentifier())) {
+      if ($notnull_bool(!$notnull_bool(this._peekIdentifier()))) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 lang_Parser.prototype.stringInterpolation = function() {
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
@@ skipping 50 matching lines @@
   }
   else if ($notnull_bool($eq(kind, 66/*TokenKind.INCOMPLETE_STRING*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 lang_Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   var args = this.arguments();
-  if ($notnull_bool(!this._inInitializers && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/)))) {
+  if ($notnull_bool(!$notnull_bool(this._inInitializers) && (this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/)))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     if ($notnull_bool(args.length == 1)) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
@@ skipping 18 matching lines @@
 
     case 108/*TokenKind.THIS*/:
 
       this._eat(108/*TokenKind.THIS*/);
       this._eat(14/*TokenKind.DOT*/);
       name = ('this.' + this.identifier().get$name() + '');
       break;
 
     case 76/*TokenKind.GET*/:
 
-      if ($notnull_bool(!includeOperators)) return null;
+      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
       this._eat(76/*TokenKind.GET*/);
       if ($notnull_bool(this._peekIdentifier())) {
         name = ('get\$' + this.identifier().get$name() + '');
       }
       else {
         name = 'get';
       }
       break;
 
     case 84/*TokenKind.SET*/:
 
-      if ($notnull_bool(!includeOperators)) return null;
+      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
       this._eat(84/*TokenKind.SET*/);
       if ($notnull_bool(this._peekIdentifier())) {
         name = ('set\$' + this.identifier().get$name() + '');
       }
       else {
         name = 'set';
       }
       break;
 
     case 83/*TokenKind.OPERATOR*/:
 
-      if ($notnull_bool(!includeOperators)) return null;
+      if ($notnull_bool(!$notnull_bool(includeOperators))) return null;
       this._eat(83/*TokenKind.OPERATOR*/);
       var kind = this._peek();
       if ($notnull_bool($eq(kind, 82/*TokenKind.NEGATE*/))) {
         name = '\$negate';
         this._lang_next();
       }
       else {
         name = TokenKind.binaryMethodName($assert_num(kind));
         if ($notnull_bool(name == null)) {
           name = 'operator';
@@ skipping 64 matching lines @@
   }
   var args = this.arguments();
   return new lang_NewExpression(isConst, type0, name, args, this._makeSpan(start));
 }
 lang_Parser.prototype.finishListLiteral = function(start, isConst, type0) {
   if ($notnull_bool(this._maybeEat(56/*TokenKind.INDEX*/))) {
     return new ListExpression(isConst, type0, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
-  while ($notnull_bool(!this._maybeEat(5/*TokenKind.RBRACK*/))) {
+  while ($notnull_bool(!$notnull_bool(this._maybeEat(5/*TokenKind.RBRACK*/)))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     values.add(this.expression());
-    if ($notnull_bool(!this._maybeEat(11/*TokenKind.COMMA*/))) {
+    if ($notnull_bool(!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
   return new ListExpression(isConst, type0, values, this._makeSpan(start));
 }
 lang_Parser.prototype.finishMapLiteral = function(start, isConst, type0) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
-  while ($notnull_bool(!this._maybeEat(7/*TokenKind.RBRACE*/))) {
+  while ($notnull_bool(!$notnull_bool(this._maybeEat(7/*TokenKind.RBRACE*/)))) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     items.add(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add(this.expression());
-    if ($notnull_bool(!this._maybeEat(11/*TokenKind.COMMA*/))) {
+    if ($notnull_bool(!$notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
   return new MapExpression(isConst, type0, items, this._makeSpan(start));
 }
 lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, (span && span.is$SourceSpan()));
   var genericType = this.addTypeArguments((typeToBeNamedLater && typeToBeNamedLater.is$TypeReference()), 0);
@@ skipping 44 matching lines @@
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add(tp);
     if ($notnull_bool((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0)) {
       closed = true;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
-  if ($notnull_bool(!closed)) {
+  if ($notnull_bool(!$notnull_bool(closed))) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
 lang_Parser.prototype.get$typeParameters = function() {
   return lang_Parser.prototype.typeParameters.bind(this);
 }
 lang_Parser.prototype._eatClosingAngle = function(depth) {
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     return depth;
@@ skipping 83 matching lines @@
 }
 lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
   var type0 = di.type;
   var name = di.get$name();
   var value = null;
   if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
-    if ($notnull_bool(!inOptionalBlock)) {
+    if ($notnull_bool(!$notnull_bool(inOptionalBlock))) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if ($notnull_bool(this._peekKind(2/*TokenKind.LPAREN*/))) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type0, name, formals, null, null, this._makeSpan(start));
     type0 = new FunctionTypeReference(false, func, func.get$span());
   }
   if ($notnull_bool(inOptionalBlock && value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type0, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
-  if ($notnull_bool(!this._maybeEat(3/*TokenKind.RPAREN*/))) {
+  if ($notnull_bool(!$notnull_bool(this._maybeEat(3/*TokenKind.RPAREN*/)))) {
     if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
       inOptionalBlock = true;
     }
     formals.add(this.formalParameter($assert_bool(inOptionalBlock)));
     while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       if ($notnull_bool(this._maybeEat(4/*TokenKind.LBRACK*/))) {
         if ($notnull_bool(inOptionalBlock)) {
           this._lang_error('already inside an optional block', this._previousToken.get$span());
         }
         inOptionalBlock = true;
       }
       formals.add(this.formalParameter($assert_bool(inOptionalBlock)));
     }
     if ($notnull_bool(inOptionalBlock)) {
       this._eat(5/*TokenKind.RBRACK*/);
     }
     this._eat(3/*TokenKind.RPAREN*/);
   }
   return formals;
 }
 lang_Parser.prototype.identifier = function() {
   var tok = this._lang_next();
-  if ($notnull_bool(!TokenKind.isIdentifier(tok.kind))) {
+  if ($notnull_bool(!$notnull_bool(TokenKind.isIdentifier(tok.kind)))) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
   return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
 lang_Parser.prototype._makeFunction = function(expr, body) {
   var name, type0;
   if ($notnull_bool((expr instanceof CallExpression))) {
     if ($notnull_bool((expr.target instanceof VarExpression))) {
       name = expr.target.get$name();
       type0 = null;
@@ skipping 82 matching lines @@
           break;
         }
         else {
           typeParams.add(this._makeType(expr));
         }
       }
       formals.add(formal);
     }
     else if ($notnull_bool(!!(formal && formal.is$List))) {
       formals.addAll(formal);
-      if ($notnull_bool(!allowOptional)) {
+      if ($notnull_bool(!$notnull_bool(allowOptional))) {
         this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
       }
     }
     else {
       formals.add(formal);
     }
   }
   return formals;
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
@@ skipping 705 matching lines @@
   this.isTested = false;
   // Initializers done
 }
 lang_Type.prototype.is$lang_Type = function(){return this;};
 lang_Type.prototype.is$Named = function(){return this;};
 lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
-  var $0;
   if ($notnull_bool(this._typeMember == null)) {
-    this._typeMember = new TypeMember((($0 = this) && $0.is$DefinedType()));
+    this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
   return this._typeMember;
 }
 lang_Type.prototype.getMember = function(name0) {
   return null;
 }
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
 lang_Type.prototype.get$isTop = function() {
@@ skipping 65 matching lines @@
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
 lang_Type.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 lang_Type.prototype.ensureSubtypeOf = function(other, span0, typeErrors) {
-  if ($notnull_bool(!this.isSubtypeOf(other))) {
+  if ($notnull_bool(!$notnull_bool(this.isSubtypeOf(other)))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name + '');
     if ($notnull_bool(typeErrors)) {
       world.error($assert_String(msg), span0);
     }
     else {
       world.warning($assert_String(msg), span0);
     }
   }
 }
 lang_Type.prototype.needsVarCall = function(args) {
   if ($notnull_bool(this.get$isVarOrFunction())) {
     return true;
   }
   var call = this.getCallMethod();
   if ($notnull_bool($ne(call, null))) {
-    if ($notnull_bool(args.get$length() != call.get$parameters().length || !call.namesInOrder(args))) {
+    if ($notnull_bool(args.get$length() != call.get$parameters().length || !$notnull_bool(call.namesInOrder(args)))) {
       return true;
     }
   }
   return false;
 }
 lang_Type.union = function(x, y) {
   if ($notnull_bool($eq(x, y))) return x;
   if ($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;
@@ skipping 28 matching lines @@
   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)) {
     var t = this.get$typeArgsInOrder().iterator();
     var s = other.get$typeArgsInOrder().iterator();
     while ($notnull_bool(t.hasNext())) {
-      if ($notnull_bool(!t.next().isSubtypeOf(s.next()))) return false;
+      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;
   }
   if ($notnull_bool(this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf(other);
   })
   ))) {
     return true;
   }
   return false;
 }
 lang_Type._isFunctionSubtypeOf = function(t, s) {
   var $0;
-  if ($notnull_bool(!s.returnType.get$isVoid() && !s.returnType.isAssignable(t.returnType))) {
+  if ($notnull_bool(!$notnull_bool(s.returnType.get$isVoid()) && !$notnull_bool(s.returnType.isAssignable(t.returnType)))) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
   if ($notnull_bool(tp.length < sp.length)) return false;
   for (var i = 0;
    $notnull_bool(i < sp.length); i++) {
     if ($notnull_bool($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional()))) return false;
     if ($notnull_bool(tp.$index(i).get$isOptional() && $ne(tp.$index(i).get$name(), sp.$index(i).get$name()))) return false;
-    if ($notnull_bool(!tp.$index(i).type.isAssignable((($0 = sp.$index(i).type) && $0.is$lang_Type())))) return false;
+    if ($notnull_bool(!$notnull_bool(tp.$index(i).type.isAssignable((($0 = sp.$index(i).type) && $0.is$lang_Type()))))) return false;
   }
-  if ($notnull_bool(tp.length > sp.length && !tp.$index(sp.length).get$isOptional())) return false;
+  if ($notnull_bool(tp.length > sp.length && !$notnull_bool(tp.$index(sp.length).get$isOptional()))) return false;
   return true;
 }
 // ********** Code for ParameterType **************
 function ParameterType(name0, typeParameter) {
   this.typeParameter = typeParameter;
   lang_Type.call(this, name0);
   // Initializers done
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.get$isClass = function() {
@@ skipping 67 matching lines @@
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   var newTypeArgs = [];
   var needsNewType = false;
   var $list = this.typeArgsInOrder;
   for (var $i = 0;$i < $list.length; $i++) {
     var t = $list.$index($i);
     var newType = t.resolveTypeParams(inType);
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add(newType);
   }
-  if ($notnull_bool(!needsNewType)) return this;
+  if ($notnull_bool(!$notnull_bool(needsNewType))) return this;
   return this.genericType.getOrMakeConcreteType(newTypeArgs);
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
   return this.genericType.get$parent();
 }
 ConcreteType.prototype.get$interfaces = function() {
   if ($notnull_bool(this._interfaces == null && this.genericType.get$interfaces() != null)) {
@@ skipping 32 matching lines @@
   return this.genericType.getFactory(type, constructorName);
 }
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
   if ($notnull_bool(genericMember == null)) return null;
   if ($notnull_bool($ne(genericMember.declaringType, this.genericType))) {
-    if ($notnull_bool(!genericMember.declaringType.get$isGeneric())) return genericMember;
+    if ($notnull_bool(!$notnull_bool(genericMember.declaringType.get$isGeneric()))) return genericMember;
     var newDeclaringType = genericMember.declaringType.getOrMakeConcreteType(this.typeArgsInOrder);
     return newDeclaringType.getConstructor(constructorName);
   }
   if ($notnull_bool(genericMember.get$isFactory())) {
     ret = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
     this.factories.addFactory(this.name, constructorName, (ret && ret.is$Member()));
   }
   else {
     ret = new ConcreteMember(this.name, this, genericMember);
     this.constructors.$setindex(constructorName, ret);
@@ skipping 109 matching lines @@
 DefinedType.prototype.get$isList = function() {
   return this.library.get$isCore() && this.name == 'List';
 }
 DefinedType.prototype.get$isGeneric = function() {
   return this.typeParameters != null;
 }
 DefinedType.prototype.get$span = function() {
   return $notnull_bool(this.definition == null) ? null : this.definition.span;
 }
 DefinedType.prototype.get$typeofName = function() {
-  if ($notnull_bool(!this.library.get$isCore())) return null;
+  if ($notnull_bool(!$notnull_bool(this.library.get$isCore()))) return null;
   if ($notnull_bool(this.get$isBool())) return 'boolean';
   else if ($notnull_bool(this.get$isNum())) return 'number';
   else if ($notnull_bool(this.get$isString())) return 'string';
   else if ($notnull_bool(this.get$isFunction())) return 'function';
   else return null;
 }
 DefinedType.prototype.get$isNum = function() {
   return this.library != null && this.library.get$isCore() && (this.name == 'num' || this.name == 'int' || this.name == 'double');
 }
 DefinedType.prototype.getCallMethod = function() {
@@ skipping 23 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 interfaces0 = [];
   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() && !(this.library.get$isCore() || this.library.get$isCoreImpl()))) {
+    if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool((this.library.get$isCore() || this.library.get$isCoreImpl())))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
     interfaces0.add(resolvedInterface);
   }
   return interfaces0;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
   $assert(this._subtypes == null, "_subtypes == null", "type.dart", 657, 12);
   this.directSubtypes.add(type);
@@ skipping 61 matching lines @@
       if ($notnull_bool(this.definition.extendsTypes != null && this.definition.extendsTypes.length > 0)) {
         if ($notnull_bool(this.definition.extendsTypes.length > 1)) {
           world.error('more than one base class', this.definition.extendsTypes.$index(1).get$span());
         }
         var extendsTypeRef = this.definition.extendsTypes.$index(0);
         if ($notnull_bool((extendsTypeRef instanceof GenericTypeReference))) {
           var g = extendsTypeRef;
           this.parent = this.resolveType(g.baseType, true);
         }
         this.parent = this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true);
-        if ($notnull_bool(!this.parent.get$isClass())) {
+        if ($notnull_bool(!$notnull_bool(this.parent.get$isClass()))) {
           world.error('class may not extend an interface - use implements', this.definition.extendsTypes.$index(0).get$span());
         }
         this.parent.addDirectSubtype(this);
         if ($notnull_bool(this._cycleInClassExtends())) {
           world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
         }
       }
       else {
-        if ($notnull_bool(!this.get$isObject())) {
+        if ($notnull_bool(!$notnull_bool(this.get$isObject()))) {
           this.parent = world.objectType;
         }
       }
       this.interfaces = this._resolveInterfaces(this.definition.implementsTypes);
       if ($notnull_bool(this.definition.factoryType != null)) {
         world.error('factory not allowed on classes', this.definition.factoryType.span);
       }
     }
     else {
       if ($notnull_bool(this.definition.implementsTypes != null && this.definition.implementsTypes.length > 0)) {
@@ skipping 145 matching lines @@
     this.constructors.$index('').resolve(this);
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var member = this.members.$index(memberName);
   if ($notnull_bool(member != null)) {
     var parentMember = this.getMemberInParents(memberName);
     if ($notnull_bool($ne(parentMember, null))) {
-      if ($notnull_bool(!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library()))) {
+      if ($notnull_bool(!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library()))) {
         member.override(parentMember);
       }
     }
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return libType.get$typeMember();
     }
@@ skipping 42 matching lines @@
   ret = new MemberSet(member);
   this._resolvedMembers.$setindex(memberName, ret);
   if ($notnull_bool(member.get$isStatic())) {
     return ret;
   }
   else {
     var $list = this.get$subtypes();
     for (var $i = this.get$subtypes().iterator(); $i.hasNext(); ) {
       var t = $i.next();
       var m;
-      if ($notnull_bool(!this.isClass && t.get$isClass())) {
+      if ($notnull_bool(!$notnull_bool(this.isClass) && t.get$isClass())) {
         m = t.getMember(memberName);
       }
       else {
         m = t.members.$index(memberName);
       }
       if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
     }
     return ret;
   }
 }
@@ skipping 53 matching lines @@
         node.type = world.objectType;
       }
       else {
         world.warning($assert_String(message), node.span);
         node.type = world.varType;
       }
     }
   }
   else if ($notnull_bool((node instanceof GenericTypeReference))) {
     var baseType = this.resolveType(node.baseType, typeErrors);
-    if ($notnull_bool(!baseType.get$isGeneric())) {
+    if ($notnull_bool(!$notnull_bool(baseType.get$isGeneric()))) {
       world.error(('' + baseType.get$name() + ' is not generic'), node.span);
       return null;
     }
     if ($notnull_bool(node.typeArguments.length != baseType.get$typeParameters().length)) {
       world.error('wrong number of type arguments', node.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
      $notnull_bool(i < node.typeArguments.length); i++) {
@@ skipping 169 matching lines @@
     return true;
   }
   if ($notnull_bool(this.type.get$isVarOrFunction() && name == '\$call')) {
     return true;
   }
   var member = this._tryResolveMember(context, name);
   return $ne(member, null) && member.canInvoke(context, args);
 }
 Value.prototype._tryResolveMember = function(context, name) {
   var member = null;
-  if ($notnull_bool(!this.type.get$isVar())) {
+  if ($notnull_bool(!$notnull_bool(this.type.get$isVar()))) {
     if ($notnull_bool(this.isSuper)) {
       return this.type.getMember(name);
     }
     else {
       member = this.type.resolveMember(name);
     }
   }
   if ($notnull_bool(member == null)) {
     member = context.findMembers(name);
   }
   return member;
 }
 Value.prototype._resolveMember = function(context, name, node) {
   var member = this._tryResolveMember(context, name);
   if ($notnull_bool($ne(member, null))) {
-    if ($notnull_bool(this.isType && !member.get$isStatic())) {
+    if ($notnull_bool(this.isType && !$notnull_bool(member.get$isStatic()))) {
       world.error('can not refer to instance member as static', node.span);
     }
     return member;
   }
   else {
     if ($notnull_bool(this._tryResolveMember(context, 'noSuchMethod').members.length > 1)) {
       return null;
     }
     var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
     var message = ('can not resolve "' + name + '" on "' + typeName + '"');
@@ skipping 31 matching lines @@
     var fromType = this.type;
     if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
       fromType = world.objectType;
     }
     var bothNum = this.type.get$isNum() && toType.get$isNum();
     return fromType.isSubtypeOf(toType) || bothNum;
   }
   return false;
 }
 Value.prototype.convertTo = function(context, toType, node, isDynamic) {
-  var checked = !isDynamic;
+  var checked = !$notnull_bool(isDynamic);
   var callMethod = toType.getCallMethod();
   if ($notnull_bool($ne(callMethod, null))) {
-    if ($notnull_bool(checked && !toType.isAssignable(this.type))) {
+    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));
       return new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), false, true, false);
     }
   }
-  if ($notnull_bool(!options.enableTypeChecks)) {
+  if ($notnull_bool(!$notnull_bool(options.enableTypeChecks))) {
     return this;
   }
   var fromType = this.type;
   if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
     fromType = world.objectType;
   }
   var bothNum = this.type.get$isNum() && toType.get$isNum();
-  if ($notnull_bool(!checked || fromType.isSubtypeOf(toType) || bothNum)) {
+  if ($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType) || bothNum)) {
     return this;
   }
-  if ($notnull_bool(!toType.isSubtypeOf(this.type))) {
+  if ($notnull_bool(!$notnull_bool(toType.isSubtypeOf(this.type)))) {
     this.convertWarning(toType, node);
   }
   return this._typeAssert(context, toType, node);
 }
 Value.prototype.convertToNonNullBool = function(context, node) {
-  if ($notnull_bool(!this.type.isAssignable(world.boolType))) {
+  if ($notnull_bool(!$notnull_bool(this.type.isAssignable(world.boolType)))) {
     this.convertWarning(world.boolType, node);
   }
-  if ($notnull_bool(!options.enableTypeChecks)) {
+  if ($notnull_bool(!$notnull_bool(options.enableTypeChecks))) {
     return this;
   }
   else {
     if ($notnull_bool(this.code.startsWith('\$notnull_bool'))) {
       return this;
     }
     else {
       return new Value(world.boolType, ('\$notnull_bool(' + this.code + ')'), false, true, false);
     }
   }
@@ skipping 34 matching lines @@
   var testCode = null;
   if ($notnull_bool(toType.get$library().get$isCore())) {
     var typeofName = toType.get$typeofName();
     if ($notnull_bool($ne(typeofName, null))) {
       testCode = ("(typeof(" + this.code + ") " + ($notnull_bool(isTrue) ? '==' : '!=') + " '" + typeofName + "')");
     }
   }
   if ($notnull_bool(toType.get$isClass() && !(toType instanceof ConcreteType))) {
     toType.markUsed();
     testCode = ('(' + this.code + ' instanceof ' + toType.get$jsname() + ')');
-    if ($notnull_bool(!isTrue)) {
+    if ($notnull_bool(!$notnull_bool(isTrue))) {
       testCode = '!' + testCode;
     }
   }
   if ($notnull_bool(testCode == null)) {
     toType.isTested = true;
     var temp = context.getTemp(this);
     testCode = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
     testCode = testCode + (' ' + temp.code + '.is\$' + toType.get$jsname() + ')');
     if ($notnull_bool(isTrue)) {
       testCode = '!!' + testCode;
@@ skipping 16 matching lines @@
      $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 + '"'), false, true, false), new Value(world.listType, ('[' + pos + ']'), false, true, false)];
   return this._tryResolveMember(context, 'noSuchMethod').invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
   $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 417, 12);
-  $assert(!args.get$hasNames(), "!args.hasNames", "value.dart", 418, 12);
+  $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 418, 12);
   var argsString = args.getCode();
   if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
     if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
 Value.prototype.get_$3 = function($0, $1, $2) {
@@ skipping 84 matching lines @@
   return new ConstObjectValue._internal$ctor(type0, fields0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for GlobalValue **************
 function GlobalValue(type0, code0, isConst0, field, name, exp, canonicalCode, original, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.original = original;
   this.dependencies = dependencies;
-  Value.call(this, type0, code0, false, !isConst0, false);
+  Value.call(this, type0, code0, false, !$notnull_bool(isConst0), false);
   // Initializers done
 }
 $inherits(GlobalValue, Value);
 GlobalValue.GlobalValue$fromStatic$factory = function(field0, exp0, dependencies0) {
   var code0 = ($notnull_bool(exp0.get$isConst()) ? exp0.canonicalCode : exp0.code);
   var codeWithComment = ('' + code0 + '/*' + field0.declaringType.name + '.' + field0.get$name() + '*/');
   return new GlobalValue(exp0.type, codeWithComment, field0.isFinal, field0, null, exp0, code0, null, dependencies0.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
@@ skipping 92 matching lines @@
   this.numType = (($0 = this._addToCoreLib('num', false)) && $0.is$lang_Type());
   this.intType = (($0 = this._addToCoreLib('int', false)) && $0.is$lang_Type());
   this.doubleType = (($0 = this._addToCoreLib('double', false)) && $0.is$lang_Type());
   this.boolType = (($0 = this._addToCoreLib('bool', false)) && $0.is$lang_Type());
   this.stringType = (($0 = this._addToCoreLib('String', false)) && $0.is$lang_Type());
   this.listType = (($0 = this._addToCoreLib('List', false)) && $0.is$lang_Type());
   this.mapType = (($0 = this._addToCoreLib('Map', false)) && $0.is$lang_Type());
   this.functionType = (($0 = this._addToCoreLib('Function', false)) && $0.is$lang_Type());
 }
 World.prototype._addMember = function(member) {
-  $assert(!member.get$isPrivate(), "!member.isPrivate", "world.dart", 141, 12);
+  $assert(!$notnull_bool(member.get$isPrivate()), "!member.isPrivate", "world.dart", 141, 12);
   if ($notnull_bool(member.get$isStatic())) {
     if ($notnull_bool(member.declaringType.get$isTop())) {
       this._addTopName(member);
     }
     return;
   }
   var mset = this._members.$index(member.name);
   if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member);
     this._members.$setindex(mset.get$name(), mset);
@@ skipping 34 matching lines @@
 }
 World.prototype._addJavascriptTopName = function(named) {
   named.set$jsname(('' + named.get$library().get$jsname() + '_' + named.get$name() + ''));
   var existing = this._topNames.$index(named.get$jsname());
   if ($notnull_bool($ne(existing, null) && $ne(existing, named))) {
     world.internalError(('name mangling failed for "' + named.get$jsname() + '" ') + ('("' + named.get$jsname() + '" defined also in ' + existing.get$span().get$locationText() + ')'), named.get$span());
   }
   this._topNames.$setindex(named.get$jsname(), named);
 }
 World.prototype._addType = function(type) {
-  if ($notnull_bool(!type.get$isTop())) this._addTopName(type);
+  if ($notnull_bool(!$notnull_bool(type.get$isTop()))) this._addTopName(type);
 }
 World.prototype._addToCoreLib = function(name, isClass) {
   var ret = new DefinedType(name, this.corelib, null, isClass);
   this.corelib.types.$setindex(name, ret);
   return ret;
 }
 World.prototype.toJsIdentifier = function(name) {
   if ($notnull_bool(this._jsKeywords == null)) {
     this._jsKeywords = HashSetImplementation.HashSetImplementation$from$factory(['break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof', 'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'class', 'enum', 'export', 'extends', 'import', 'super', 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static', 'yield', 'native']);
   }
   if ($notnull_bool(this._jsKeywords.contains(name))) {
     return name + '_';
   }
   else {
     return name;
   }
 }
 World.prototype.compile = function() {
   if ($notnull_bool(options.dartScript == null)) {
     this.fatal('no script provided to compile');
     return false;
   }
   try {
     this.info(('compiling ' + options.dartScript + ' with corelib ' + this.corelib + ''));
-    if ($notnull_bool(!this.runLeg())) this.runCompilationPhases();
+    if ($notnull_bool(!$notnull_bool(this.runLeg()))) this.runCompilationPhases();
   } catch (exc) {
     exc = $toDartException(exc);
-    if ($notnull_bool(this.get$hasErrors() && !options.throwOnErrors)) {
+    if ($notnull_bool(this.get$hasErrors() && !$notnull_bool(options.throwOnErrors))) {
     }
     else {
       throw exc;
     }
   }
   this.printStatus();
-  return !this.get$hasErrors();
+  return !$notnull_bool(this.get$hasErrors());
 }
 World.prototype.runLeg = function() {
   var $this = this; // closure support
-  if ($notnull_bool(!options.enableLeg)) return false;
+  if ($notnull_bool(!$notnull_bool(options.enableLeg))) return false;
   var res = this.withTiming('try leg compile', (function () {
     return compile($this);
   })
   );
-  if ($notnull_bool(!res && options.legOnly)) {
+  if ($notnull_bool(!$notnull_bool(res) && options.legOnly)) {
     this.fatal(("Leg could not compile " + options.dartScript + ""));
   }
   return res;
 }
 World.prototype.runCompilationPhases = function() {
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
@@ skipping 44 matching lines @@
     e = $toDartException(e);
     this.warning(('Error reading file: ' + filename + ''));
     return new SourceFile(filename, '');
   }
 }
 World.prototype.getOrAddLibrary = function(filename) {
   var library = this.libraries.$index(filename);
   if ($notnull_bool(library == null)) {
     library = new Library(this.readFile(filename));
     this.info(('read library ' + filename + ''));
-    if ($notnull_bool(!library.get$isCore() && !library.imports.some((function (li) {
+    if ($notnull_bool(!$notnull_bool(library.get$isCore()) && !$notnull_bool(library.imports.some((function (li) {
       return li.get$library().get$isCore();
     })
-    ))) {
+    )))) {
       library.imports.add(new LibraryImport(this.corelib));
     }
     this.libraries.$setindex(filename, library);
     this._todo.add(library);
   }
   return library;
 }
 World.prototype.process = function() {
   while ($notnull_bool(this._todo.length > 0)) {
     var todo = this._todo;
@@ skipping 177 matching lines @@
           break loop;
         }
         else if ($notnull_bool(arg.startsWith('--out='))) {
           this.outfile = arg.substring('--out='.length);
         }
         else if ($notnull_bool(arg.startsWith('--libdir='))) {
           this.libDir = arg.substring('--libdir='.length);
           passedLibDir = true;
         }
         else {
-          if ($notnull_bool(!ignoreUnrecognizedFlags)) {
+          if ($notnull_bool(!$notnull_bool(ignoreUnrecognizedFlags))) {
             print(('unrecognized flag: "' + arg + '"'));
           }
         }
 
     }
   }
-  if ($notnull_bool(!passedLibDir && !files.fileExists(this.libDir))) {
+  if ($notnull_bool(!$notnull_bool(passedLibDir) && !$notnull_bool(files.fileExists(this.libDir)))) {
     var temp = 'frog/lib';
     if ($notnull_bool(files.fileExists(temp))) {
       this.libDir = $assert_String(temp);
     }
     else {
       this.libDir = 'lib';
     }
   }
 }
 // ********** Code for LibraryReader **************
@@ skipping 135 matching lines @@
 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', false, true, false);
     var result = member.invoke$4(context, node, target, this.args);
     var stub = new VarMethodStub(this.name, member, this.args, result);
     var type = member.declaringType;
-    if ($notnull_bool($ne(type.get$library(), world.get$dom()) && !type.get$isObject())) {
+    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', false, true, false);
   var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
   var stub = new VarMethodStub(this.name, null, this.args, result);
   if ($notnull_bool(this._fallbackStubs.length == 0)) {
@@ skipping 113 matching lines @@
   world = new World(files);
   world.init();
 }
 function lang_compile(homedir, args, files) {
   parseOptions(homedir, args, files);
   initializeWorld(files);
   var success = world.compile();
   if ($notnull_bool(options.outfile != null)) {
     if ($notnull_bool(success)) {
       var code = world.getGeneratedCode();
-      if ($notnull_bool(!options.outfile.endsWith('.js'))) {
+      if ($notnull_bool(!$notnull_bool(options.outfile.endsWith('.js')))) {
         code = '#!/usr/bin/env node\n' + code;
       }
       world.files.writeString(options.outfile, code);
     }
     else {
       world.files.writeString(options.outfile, "throw 'Sorry, but I could not generate reasonable code to run.\\n';");
     }
   }
   return success;
 }
@@ skipping 10 matching lines @@
   }
   return nameBuilder.toString();
 }
 //  ********** Library frog **************
 // ********** Code for top level **************
 function main() {
   var homedir = get$path().dirname(get$fs().realpathSync($assert_String(process.argv.$index(1))));
   var argv = ListFactory.ListFactory$from$factory(process.argv);
   if ($notnull_bool(lang_compile($assert_String(homedir), (argv && argv.is$List$String()), new NodeFileSystem()))) {
     var code = world.getGeneratedCode();
-    if ($notnull_bool(!options.compileOnly)) {
+    if ($notnull_bool(!$notnull_bool(options.compileOnly))) {
       process.argv = [argv.$index(0), argv.$index(1)];
       process.argv.addAll(options.childArgs);
       get$vm().runInNewContext($assert_String(code), createSandbox());
     }
   }
   else {
     process.exit(1);
   }
 }
 Function.prototype.to$call$0 = function() {
@@ skipping 158 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();