Dynamically dispatch getters and setters on dynamically-typed variables.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 414 matching lines @@
 };
 Object.prototype.expectedIdentifier$1 = function($0) {
   return this.noSuchMethod("expectedIdentifier", [$0]);
 };
 Object.prototype.expectedType$1 = function($0) {
   return this.noSuchMethod("expectedType", [$0]);
 };
 Object.prototype.filter$1 = function($0) {
   return this.noSuchMethod("filter", [$0]);
 };
+Object.prototype.findTypeByName$1 = function($0) {
+  return this.noSuchMethod("findTypeByName", [$0]);
+};
+Object.prototype.forEach$1 = function($0) {
+  return this.noSuchMethod("forEach", [$0]);
+};
 Object.prototype.genValue$2 = function($0, $1) {
   return this.noSuchMethod("genValue", [$0, $1]);
 };
 Object.prototype.generate$1 = function($0) {
   return this.noSuchMethod("generate", [$0]);
 };
 Object.prototype.generateBody$2 = function($0, $1) {
   return this.noSuchMethod("generateBody", [$0, $1]);
 };
 Object.prototype.getBeginToken$0 = function() {
   return this.noSuchMethod("getBeginToken", []);
 };
+Object.prototype.getColumn$2 = function($0, $1) {
+  return this.noSuchMethod("getColumn", [$0, $1]);
+};
 Object.prototype.getConstructor$1 = function($0) {
   return this.noSuchMethod("getConstructor", [$0]);
 };
 Object.prototype.getEndToken$0 = function() {
   return this.noSuchMethod("getEndToken", []);
 };
 Object.prototype.getFactory$2 = function($0, $1) {
   return this.noSuchMethod("getFactory", [$0, $1]);
 };
 Object.prototype.getKeys$0 = function() {
   return this.noSuchMethod("getKeys", []);
 };
+Object.prototype.getLine$1 = function($0) {
+  return this.noSuchMethod("getLine", [$0]);
+};
 Object.prototype.getMember$1 = function($0) {
   return this.noSuchMethod("getMember", [$0]);
 };
 Object.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.noSuchMethod("getOrMakeConcreteType", [$0]);
 };
 Object.prototype.get_$3 = function($0, $1, $2) {
   return this.noSuchMethod("get_", [$0, $1, $2]);
 };
 Object.prototype.handleAssignmentExpression$1 = function($0) {
@@ skipping 864 matching lines @@
 }
 
 function _IsolateJsUtil() {}
 // ********** Code for ListFactory **************
 ListFactory = Array;
 ListFactory.prototype.is$ListFactory = function(){return this;};
 ListFactory.prototype.is$List = function(){return this;};
 ListFactory.prototype.is$List$ArgumentNode = function(){return this;};
 ListFactory.prototype.is$List$Definition = function(){return this;};
 ListFactory.prototype.is$List$EvaluatedValue = function(){return this;};
+ListFactory.prototype.is$List$HInstruction = function(){return this;};
+ListFactory.prototype.is$List$Member = function(){return this;};
 ListFactory.prototype.is$List$String = function(){return this;};
 ListFactory.prototype.is$List$Type = function(){return this;};
 ListFactory.prototype.is$List$Value = function(){return this;};
 ListFactory.prototype.is$List$int = function(){return this;};
 ListFactory.prototype.is$Collection$E = function(){return this;};
 ListFactory.prototype.is$Collection$Object = function(){return this;};
 ListFactory.prototype.is$Collection$Type = function(){return this;};
 ListFactory.prototype.is$Iterable = function(){return this;};
 ListFactory.ListFactory$from$factory = function(other) {
   var list = [];
@@ skipping 31 matching lines @@
   return this.length == 0;
 }
 ListFactory.prototype.iterator = function() {
   return new ListIterator(this);
 }
 ListFactory.prototype.add$1 = ListFactory.prototype.add;
 ListFactory.prototype.addAll$1 = function($0) {
   return this.addAll(($0 && $0.is$Collection$E()));
 };
 ListFactory.prototype.filter$1 = ListFactory.prototype.filter;
+ListFactory.prototype.forEach$1 = ListFactory.prototype.forEach;
 ListFactory.prototype.indexOf$2 = ListFactory.prototype.indexOf;
 ListFactory.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 ListFactory.prototype.iterator$0 = function() {
   return this.iterator();
 };
 ListFactory.prototype.last$0 = function() {
   return this.last();
 };
@@ skipping 137 matching lines @@
 }
 ImmutableMap.prototype.getValues = function() {
   return this._internal.getValues();
 }
 ImmutableMap.prototype.containsKey = function(key) {
   return this._internal.containsKey(key);
 }
 ImmutableMap.prototype.$setindex = function(key, value) {
   $throw(const$12/*const IllegalAccessException()*/);
 }
+ImmutableMap.prototype.forEach$1 = ImmutableMap.prototype.forEach;
 ImmutableMap.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 ImmutableMap.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for MatchImplementation **************
 function MatchImplementation(pattern, str, _start, _end, _groups) {
   this.pattern = pattern;
   this.str = str;
@@ skipping 234 matching lines @@
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, value);
   }
   );
   return list;
 }
 HashMapImplementation.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
+HashMapImplementation.prototype.forEach$1 = HashMapImplementation.prototype.forEach;
 HashMapImplementation.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 HashMapImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for HashMapImplementation$E$E **************
 function HashMapImplementation$E$E() {
   // Initializers done
   if (HashMapImplementation._deletedKey == null) {
@@ skipping 210 matching lines @@
 });
 HashSetImplementation.prototype.iterator = function() {
   return new HashSetIterator$E(this);
 }
 HashSetImplementation.prototype.add$1 = HashSetImplementation.prototype.add;
 HashSetImplementation.prototype.addAll$1 = function($0) {
   return this.addAll(($0 && $0.is$Collection$E()));
 };
 HashSetImplementation.prototype.contains$1 = HashSetImplementation.prototype.contains;
 HashSetImplementation.prototype.filter$1 = HashSetImplementation.prototype.filter;
+HashSetImplementation.prototype.forEach$1 = HashSetImplementation.prototype.forEach;
 HashSetImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 HashSetImplementation.prototype.iterator$0 = function() {
   return this.iterator();
 };
 HashSetImplementation.prototype.some$1 = HashSetImplementation.prototype.some;
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {}
 $inherits(HashSetImplementation$E, HashSetImplementation);
@@ skipping 91 matching lines @@
 // ********** Code for LinkedHashMapImplementation **************
 function LinkedHashMapImplementation() {
   // Initializers done
   this._map = new HashMapImplementation();
   this._list = new DoubleLinkedQueue$KeyValuePair$K$V();
 }
 LinkedHashMapImplementation.prototype.is$Map$Node$Element = function(){return this;};
 LinkedHashMapImplementation.prototype.is$Map$String$Member = function(){return this;};
 LinkedHashMapImplementation.prototype.$setindex = function(key, value) {
   if (this._map.containsKey(key)) {
-    this._map.$index(key).get$element().value = value;
+    this._map.$index(key).get$element().set$value(value);
   }
   else {
     this._list.addLast(new KeyValuePair$K$V(key, value));
     this._map.$setindex(key, this._list.lastEntry());
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
   var $0;
   var entry = (($0 = this._map.$index(key)) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
   if (entry == null) return null;
@@ skipping 30 matching lines @@
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.get$length();
 }
 Object.defineProperty(LinkedHashMapImplementation.prototype, "length", {
   get: LinkedHashMapImplementation.prototype.get$length
 });
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
+LinkedHashMapImplementation.prototype.forEach$1 = LinkedHashMapImplementation.prototype.forEach;
 LinkedHashMapImplementation.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 LinkedHashMapImplementation.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for LinkedHashMapImplementation$Node$Element **************
 function LinkedHashMapImplementation$Node$Element() {}
 $inherits(LinkedHashMapImplementation$Node$Element, LinkedHashMapImplementation);
 LinkedHashMapImplementation$Node$Element.prototype.is$Map$Node$Element = function(){return this;};
@@ skipping 171 matching lines @@
 }
 Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
   get: DoubleLinkedQueue.prototype.get$length
 });
 DoubleLinkedQueue.prototype.isEmpty = function() {
   return (this._sentinel._next === this._sentinel);
 }
 DoubleLinkedQueue.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
+    var nextEntry = entry._next;
     f(entry._element);
-    entry = entry._next;
+    entry = nextEntry;
   }
 }
 DoubleLinkedQueue.prototype.some = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
+    var nextEntry = entry._next;
     if (f(entry._element)) return true;
-    entry = entry._next;
+    entry = nextEntry;
   }
   return false;
 }
 DoubleLinkedQueue.prototype.filter = function(f) {
   var other = new DoubleLinkedQueue();
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
+    var nextEntry = entry._next;
     if (f(entry._element)) other.addLast(entry._element);
-    entry = entry._next;
+    entry = nextEntry;
   }
   return other;
 }
 DoubleLinkedQueue.prototype.iterator = function() {
   return new _DoubleLinkedQueueIterator$E(this._sentinel);
 }
 DoubleLinkedQueue.prototype.add$1 = DoubleLinkedQueue.prototype.add;
 DoubleLinkedQueue.prototype.addAll$1 = function($0) {
   return this.addAll(($0 && $0.is$Collection$E()));
 };
 DoubleLinkedQueue.prototype.filter$1 = DoubleLinkedQueue.prototype.filter;
+DoubleLinkedQueue.prototype.forEach$1 = DoubleLinkedQueue.prototype.forEach;
 DoubleLinkedQueue.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 DoubleLinkedQueue.prototype.iterator$0 = function() {
   return this.iterator();
 };
 DoubleLinkedQueue.prototype.last$0 = function() {
   return this.last();
 };
 DoubleLinkedQueue.prototype.removeLast$0 = function() {
@@ skipping 26 matching lines @@
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.is$Iterable = function(){return this;};
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.addLast = function(value) {
   this._sentinel.prepend(value);
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.lastEntry = function() {
   return this._sentinel.previousEntry();
 }
 DoubleLinkedQueue$KeyValuePair$K$V.prototype.forEach = function(f) {
   var entry = this._sentinel._next;
   while (entry !== this._sentinel) {
+    var nextEntry = entry._next;
     f(entry._element);
-    entry = entry._next;
+    entry = nextEntry;
   }
 }
 // ********** Code for DoubleLinkedQueue$SourceString **************
 function DoubleLinkedQueue$SourceString() {}
 $inherits(DoubleLinkedQueue$SourceString, DoubleLinkedQueue);
 DoubleLinkedQueue$SourceString.prototype.is$Collection$E = function(){return this;};
 DoubleLinkedQueue$SourceString.prototype.is$Collection$Object = function(){return this;};
 DoubleLinkedQueue$SourceString.prototype.is$Collection$Type = false;
 DoubleLinkedQueue$SourceString.prototype.is$Iterable = function(){return this;};
 // ********** Code for _DoubleLinkedQueueIterator **************
@@ skipping 37 matching lines @@
   if (this._start == null) {
     this._start = Clock.now();
   }
   else {
     if (this._stop == null) {
       return;
     }
     this._start = Clock.now() - (this._stop - this._start);
   }
 }
+StopwatchImplementation.prototype.get$start = function() {
+  return StopwatchImplementation.prototype.start.bind(this);
+}
 StopwatchImplementation.prototype.stop = function() {
   if (this._start == null) {
     return;
   }
   this._stop = Clock.now();
 }
 StopwatchImplementation.prototype.elapsed = function() {
   if (this._start == null) {
     return 0;
   }
@@ skipping 192 matching lines @@
 DateImplementation.now$ctor = function() {
   this.timeZone = new TimeZoneImplementation.local$ctor();
   this.value = DateImplementation._now();
   // Initializers done
   this._asJs();
 }
 DateImplementation.now$ctor.prototype = DateImplementation.prototype;
 DateImplementation.prototype.is$Date = function(){return this;};
 DateImplementation.prototype.is$Comparable = function(){return this;};
 DateImplementation.prototype.get$value = function() { return this.value; };
+DateImplementation.prototype.get$timeZone = function() { return this.timeZone; };
 DateImplementation.prototype.$eq = function(other) {
   if (!((other instanceof DateImplementation))) return false;
-  return (this.value == other.get$value()) && ($eq(this.timeZone, other.timeZone));
+  return (this.value == other.get$value()) && ($eq(this.timeZone, other.get$timeZone()));
 }
 DateImplementation.prototype.compareTo = function(other) {
   return this.value.compareTo(other.value);
 }
 DateImplementation.prototype.get$year = function() {
   return this.isUtc ? this._asJs().getUTCFullYear() :
       this._asJs().getFullYear();
 }
 DateImplementation.prototype.get$month = function() {
   return this.isUtc ? this._asJs().getMonth() + 1 :
@@ skipping 61 matching lines @@
 };
 // ********** Code for TimeZoneImplementation **************
 function TimeZoneImplementation() {}
 TimeZoneImplementation.local$ctor = function() {
   this.isUtc = false;
   // Initializers done
 }
 TimeZoneImplementation.local$ctor.prototype = TimeZoneImplementation.prototype;
 TimeZoneImplementation.prototype.$eq = function(other) {
   if (!((other instanceof TimeZoneImplementation))) return false;
-  return $eq(this.isUtc, other.isUtc);
+  return $eq(this.isUtc, other.get$isUtc());
 }
 TimeZoneImplementation.prototype.toString = function() {
   if ($notnull_bool(this.isUtc)) return "TimeZone (UTC)";
   return "TimeZone (Local)";
 }
+TimeZoneImplementation.prototype.get$isUtc = function() { return this.isUtc; };
 TimeZoneImplementation.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for top level **************
 //  ********** Library node **************
 // ********** Code for process **************
 // ********** Code for vm **************
 vm = require('vm');
 // ********** Code for fs **************
 fs = require('fs');
@@ skipping 311 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
-  if (this.groupingStack.get$head().kind !== openKind) {
+  if (this.groupingStack.get$head().get$kind() !== openKind) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  this.groupingStack.get$head().endGroup = oldTail.next;
+  this.groupingStack.get$head().set$endGroup(oldTail.next);
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner.prototype.appendGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
-    this.groupingStack.get$head().endGroup = oldTail.next;
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
+    this.groupingStack.get$head().set$endGroup(oldTail.next);
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 ArrayBasedScanner.prototype.appendGtGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
-    this.groupingStack.get$head().endGroup = oldTail.next;
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
+    this.groupingStack.get$head().set$endGroup(oldTail.next);
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 // ********** Code for ArrayBasedScanner$SourceString **************
 function ArrayBasedScanner$SourceString() {
   this.groupingStack = const$14/*const EmptyLink()*/
   this.extraCharOffset = 0;
   this.tokenStart = -1;
   this.byteOffset = -1;
   this.tokens = new Token(0/*null.EOF_TOKEN*/, -1);
@@ skipping 38 matching lines @@
   this.extraCharOffset += offset;
 }
 ArrayBasedScanner$SourceString.prototype.appendWhiteSpace = function(next) {
 
 }
 ArrayBasedScanner$SourceString.prototype.appendBeginGroup = function(kind, value) {
   var $0;
   var token = new BeginGroupToken(kind, value, this.tokenStart);
   this.tail.next = token;
   this.tail = this.tail.next;
-  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (kind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   this.groupingStack = (($0 = this.groupingStack.prepend(token)) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendEndGroup = function(kind, value, openKind) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().kind === 60/*null.LT_TOKEN*/) {
+  while (openKind !== 60/*null.LT_TOKEN*/ && !$notnull_bool(this.groupingStack.isEmpty()) && this.groupingStack.get$head().get$kind() === 60/*null.LT_TOKEN*/) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
-  if (this.groupingStack.get$head().kind !== openKind) {
+  if (this.groupingStack.get$head().get$kind() !== openKind) {
     if (openKind === 60/*null.LT_TOKEN*/) return;
     $throw(new MalformedInputException(('Unmatched ' + value + '')));
   }
-  this.groupingStack.get$head().endGroup = oldTail.next;
+  this.groupingStack.get$head().set$endGroup(oldTail.next);
   this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
 }
 ArrayBasedScanner$SourceString.prototype.appendGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
-    this.groupingStack.get$head().endGroup = oldTail.next;
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
+    this.groupingStack.get$head().set$endGroup(oldTail.next);
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 ArrayBasedScanner$SourceString.prototype.appendGtGtGt = function(kind, value) {
   var $0;
   var oldTail = this.tail;
   this.appendStringToken(kind, value);
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
   if ($notnull_bool(this.groupingStack.isEmpty())) return;
-  if ($notnull_bool($eq(this.groupingStack.get$head().kind, 60/*null.LT_TOKEN*/))) {
-    this.groupingStack.get$head().endGroup = oldTail.next;
+  if ($notnull_bool($eq(this.groupingStack.get$head().get$kind(), 60/*null.LT_TOKEN*/))) {
+    this.groupingStack.get$head().set$endGroup(oldTail.next);
     this.groupingStack = (($0 = this.groupingStack.get$tail()) && $0.is$Link$Token());
   }
 }
 ArrayBasedScanner$SourceString.prototype.tokenize = function() {
   var next = this.advance();
   while (next != -1) {
     next = this.bigSwitch(next);
   }
   this.appendEofToken();
   return this.firstToken();
@@ skipping 2615 matching lines @@
 }
 PartialParser.prototype.isIdentifier = function(token) {
   var kind = token.kind;
   switch (true) {
     case kind === 97/*null.IDENTIFIER_TOKEN*/:
 
       return true;
 
     case kind === 107/*null.KEYWORD_TOKEN*/:
 
-      return token.get$value().isPseudo;
+      return $assert_bool(token.get$value().get$isPseudo());
 
     default:
 
       return false;
 
   }
 }
 PartialParser.prototype.parseSupertypesClauseOpt = function(token) {
   if ($notnull_bool(this.optional('extends', token))) {
     do {
       token = this.parseType(this.next(token));
     }
     while ($notnull_bool(this.optional(',', token)))
   }
   return token;
 }
 PartialParser.prototype.parseFactoryClauseOpt = function(token) {
   if ($notnull_bool(this.optional('factory', token))) {
     return this.parseType(this.next(token));
   }
   return token;
 }
 PartialParser.prototype.skipBlock = function(token) {
+  var $0;
   if (!$notnull_bool(this.optional('{', token))) {
-    return this.listener.expectedBlock$1(token);
+    return (($0 = this.listener.expectedBlock$1(token)) && $0.is$Token());
   }
   var beginGroupToken = (token && token.is$BeginGroupToken());
   $assert(beginGroupToken.endGroup == null || beginGroupToken.endGroup.kind === 125/*null.$RBRACE*/, "beginGroupToken.endGroup === null ||\n           beginGroupToken.endGroup.kind === $RBRACE", "parser.dart", 171, 12);
   return beginGroupToken.endGroup;
 }
 PartialParser.prototype.skipArguments = function(token) {
   return token.endGroup;
 }
 PartialParser.prototype.parseClass = function(token) {
   var begin = token;
@@ skipping 41 matching lines @@
 PartialParser.prototype.parseIdentifier = function(token) {
   if ($notnull_bool(this.isIdentifier(token))) {
     this.listener.handleIdentifier$1(token);
   }
   else {
     this.listener.expectedIdentifier$1(token);
   }
   return this.next(token);
 }
 PartialParser.prototype.expect = function(string, token) {
+  var $0;
   if (string !== token.get$stringValue()) {
     if (string === '>') {
       if (token.get$stringValue() === '>>') {
         var gt = new StringToken(62/*null.GT_TOKEN*/, '>', token.charOffset + 1);
         gt.next = token.next;
         return gt;
       }
       else if (token.get$stringValue() === '>>>') {
         var gtgt = new StringToken(1024/*null.UNKNOWN_TOKEN*/, '>>', token.charOffset + 1);
         gtgt.next = token.next;
         return gtgt;
       }
     }
-    return this.listener.expected$2(string, token);
+    return (($0 = this.listener.expected$2(string, token)) && $0.is$Token());
   }
   return token.next;
 }
 PartialParser.prototype.parseTypeVariable = function(token) {
   this.listener.beginTypeVariable$1(token);
   token = this.parseIdentifier(token);
   if ($notnull_bool(this.optional('extends', token))) {
     token = this.parseType(this.next(token));
   }
   else {
     this.listener.handleNoType$1(token);
   }
   this.listener.endTypeVariable$1(token);
   return token;
 }
 PartialParser.prototype.optional = function(value, token) {
   return value === token.get$stringValue();
 }
 PartialParser.prototype.parseType = function(token) {
+  var $0;
   var begin = token;
   var identifierCount = 1;
   if ($notnull_bool(this.isIdentifier(token))) {
     token = this.parseIdentifier(token);
     while ($notnull_bool(this.optional('.', token))) {
       token = this.parseIdentifier(this.next(token));
       ++identifierCount;
     }
   }
   else if ($notnull_bool(this.optional('var', token))) {
     this.listener.handleVarKeyword$1(token);
     this.listener.endType$3(identifierCount, begin, token);
     return this.next(token);
   }
   else {
-    token = this.listener.expectedType$1(token);
+    token = (($0 = this.listener.expectedType$1(token)) && $0.is$Token());
   }
   token = this.parseTypeArgumentsOpt(token);
   this.listener.endType$3(identifierCount, begin, token);
   return token;
 }
 PartialParser.prototype.parseTypeArgumentsOpt = function(token) {
   return this.parseStuff(token, this.beginTypeArguments, this.parseTypeFunction, this.endTypeArguments, this.handleNoTypeArguments);
 }
 PartialParser.prototype.parseTypeVariablesOpt = function(token) {
   if ($notnull_bool(this.optional('<', token))) {
@@ skipping 17 matching lines @@
     endStuff.call$3(count, begin, token);
     return this.expect('>', token);
   }
   handleNoStuff.call$1(token);
   return token;
 }
 PartialParser.prototype.parseClassBody = function(token) {
   return this.skipBlock(token);
 }
 PartialParser.prototype.parseTopLevelMember = function(token) {
+  var $0;
   var start = token;
   this.listener.beginTopLevelMember$1(token);
   var previous = token;
   LOOP:
   while (token != null) {
     var kind = token.kind;
     switch (true) {
       case kind === 123/*null.LBRACE_TOKEN*/:
       case kind === 59/*null.SEMICOLON_TOKEN*/:
       case kind === 40/*null.LPAREN_TOKEN*/:
@@ skipping 14 matching lines @@
   while (true) {
     if ($notnull_bool(this.optional('(', token))) {
       isField = false;
       break;
     }
     else if ($notnull_bool(this.optional('=', token) || this.optional(';', token))) {
       isField = true;
       break;
     }
     else {
-      token = this.listener.unexpected$1(token);
+      token = (($0 = this.listener.unexpected$1(token)) && $0.is$Token());
     }
   }
   if (!$notnull_bool(isField)) {
     token = this.next(this.skipArguments((token && token.is$BeginGroupToken())));
   }
   while (token != null && token.kind !== 123/*null.LBRACE_TOKEN*/ && token.kind !== 59/*null.SEMICOLON_TOKEN*/) {
     token = this.next(token);
   }
   if (!$notnull_bool(this.optional(';', token))) {
     token = this.skipBlock(token);
@@ skipping 1452 matching lines @@
   this.tail = this.tail.next;
 }
 // ********** Code for SubstringWrapper **************
 function SubstringWrapper(internalString, begin, end) {
   this.internalString = internalString;
   this.begin = begin;
   this.end = end;
   // Initializers done
 }
 SubstringWrapper.prototype.is$SourceString = function(){return this;};
+SubstringWrapper.prototype.get$end = function() { return this.end; };
 SubstringWrapper.prototype.hashCode = function() {
   return this.toString().hashCode();
 }
 SubstringWrapper.prototype.$eq = function(other) {
   return !!(other && other.is$SourceString) && this.toString() == other.toString$0();
 }
 SubstringWrapper.prototype.printOn = function(sb) {
   sb.add(this);
 }
 SubstringWrapper.prototype.toString = function() {
@@ skipping 11 matching lines @@
 SubstringWrapper.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for Token **************
 function Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
 Token.prototype.is$Token = function(){return this;};
+Token.prototype.get$kind = function() { return this.kind; };
 Token.prototype.get$charOffset = function() { return this.charOffset; };
 Token.prototype.get$value = function() {
   return const$234/*const SourceString('EOF')*/;
 }
 Token.prototype.get$stringValue = function() {
   return 'EOF';
 }
 Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
@@ skipping 72 matching lines @@
 StringWrapper.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for BeginGroupToken **************
 function BeginGroupToken(kind, value, charOffset) {
   StringToken.call(this, kind, value, charOffset);
   // Initializers done
 }
 $inherits(BeginGroupToken, StringToken);
 BeginGroupToken.prototype.is$BeginGroupToken = function(){return this;};
+BeginGroupToken.prototype.get$endGroup = function() { return this.endGroup; };
+BeginGroupToken.prototype.set$endGroup = function(value) { return this.endGroup = value; };
 // ********** Code for Keyword **************
 function Keyword(syntax, isPseudo) {
   this.syntax = syntax;
   this.isPseudo = isPseudo;
   // Initializers done
 }
 Keyword.prototype.is$SourceString = function(){return this;};
+Keyword.prototype.get$syntax = function() { return this.syntax; };
+Keyword.prototype.get$isPseudo = function() { return this.isPseudo; };
 Keyword.get$keywords = function() {
   if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
   var result = new LinkedHashMapImplementation();
   for (var $i0 = const$232/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
     var keyword = $i0.next();
@@ skipping 26 matching lines @@
   return this.toString();
 };
 // ********** Code for KeywordState **************
 function KeywordState() {}
 KeywordState.prototype.is$KeywordState = function(){return this;};
 KeywordState.get$KEYWORD_STATE = function() {
   if (KeywordState._KEYWORD_STATE == null) {
     var strings = new ListFactory(const$232/*Keyword.values*/.get$length());
     for (var i = 0;
      i < const$232/*Keyword.values*/.get$length(); i++) {
-      strings.$setindex(i, const$232/*Keyword.values*/[i].syntax);
+      strings.$setindex(i, const$232/*Keyword.values*/[i].get$syntax());
     }
     strings.sort((function (a, b) {
       return a.compareTo$1(b);
     })
     );
     KeywordState._KEYWORD_STATE = KeywordState.computeKeywordStateTable(0, strings, 0, strings.length);
   }
   return KeywordState._KEYWORD_STATE;
 }
 KeywordState.computeKeywordStateTable = function(start, strings, offset, length) {
   var result = new ListFactory(26);
   $assert(length != 0, "length != 0", "keyword.dart", 161, 12);
   var chunk = 0;
   var chunkStart = -1;
   for (var i = offset;
    i < offset + length; i++) {
     if (strings.$index(i).length > start) {
-      var c = strings.$index(i).charCodeAt$1(start);
+      var c = $assert_num(strings.$index(i).charCodeAt$1(start));
       if (chunk != c) {
         if (chunkStart != -1) {
           result.$setindex(chunk - 97/*null.$a*/, KeywordState.computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart));
         }
         chunkStart = i;
         chunk = c;
       }
     }
   }
   if (chunkStart != -1) {
@@ skipping 261 matching lines @@
 };
 NodeList.prototype.getEndToken$0 = function() {
   return this.getEndToken();
 };
 // ********** Code for Block **************
 function Block(statements) {
   this.statements = statements;
   // Initializers done
 }
 $inherits(Block, Statement);
+Block.prototype.get$statements = function() { return this.statements; };
 Block.prototype.accept = function(visitor) {
   return visitor.visitBlock(this);
 }
 Block.prototype.getBeginToken = function() {
   return this.statements.getBeginToken();
 }
 Block.prototype.getEndToken = function() {
   return this.statements.getEndToken();
 }
 Block.prototype.accept$1 = function($0) {
@@ skipping 40 matching lines @@
 // ********** Code for For **************
 function For(initializer, condition, update, body, forToken) {
   this.initializer = initializer;
   this.condition = condition;
   this.update = update;
   this.body = body;
   this.forToken = forToken;
   // Initializers done
 }
 $inherits(For, Statement);
+For.prototype.get$body = function() { return this.body; };
 For.prototype.accept = function(visitor) {
   return visitor.visitFor(this);
 }
 For.prototype.getBeginToken = function() {
   return this.forToken;
 }
 For.prototype.getEndToken = function() {
   return this.body.getEndToken();
 }
 For.prototype.accept$1 = function($0) {
@@ skipping 10 matching lines @@
   this.name = name;
   this.parameters = parameters;
   this.body = body;
   this.returnType = returnType;
   // Initializers done
 }
 $inherits(FunctionExpression, Expression);
 FunctionExpression.prototype.is$FunctionExpression = function(){return this;};
 FunctionExpression.prototype.get$name = function() { return this.name; };
 FunctionExpression.prototype.get$parameters = function() { return this.parameters; };
+FunctionExpression.prototype.get$body = function() { return this.body; };
 FunctionExpression.prototype.get$returnType = function() { return this.returnType; };
 FunctionExpression.prototype.accept = function(visitor) {
   return visitor.visitFunctionExpression(this);
 }
 FunctionExpression.prototype.getBeginToken = function() {
   return firstBeginToken(this.returnType, this.name);
 }
 FunctionExpression.prototype.getEndToken = function() {
   return this.body.getEndToken();
 }
@@ skipping 295 matching lines @@
 // ********** Code for VariableDefinitions **************
 function VariableDefinitions(type, modifiers, definitions, endToken) {
   this.type = type;
   this.modifiers = modifiers;
   this.definitions = definitions;
   this.endToken = endToken;
   // Initializers done
 }
 $inherits(VariableDefinitions, Statement);
 VariableDefinitions.prototype.is$VariableDefinitions = function(){return this;};
+VariableDefinitions.prototype.get$type = function() { return this.type; };
 VariableDefinitions.prototype.accept = function(visitor) {
   return visitor.visitVariableDefinitions(this);
 }
 VariableDefinitions.prototype.getBeginToken = function() {
   return firstBeginToken(this.type, this.definitions);
 }
 VariableDefinitions.prototype.getEndToken = function() {
   return this.endToken;
 }
 VariableDefinitions.prototype.accept$1 = function($0) {
@@ skipping 155 matching lines @@
 function firstBeginToken(first, second) {
   var $0;
   return (($0 = (first != null) ? first.getBeginToken() : second.getBeginToken()) && $0.is$Token());
 }
 //  ********** Library elements **************
 // ********** Code for ElementKind **************
 function ElementKind(id) {
   this.id = id;
   // Initializers done
 }
+ElementKind.prototype.get$id = function() { return this.id; };
 // ********** Code for Element **************
 function Element(name, kind, enclosingElement) {
   this.name = name;
   this.kind = kind;
   this.enclosingElement = enclosingElement;
   // Initializers done
 }
 Element.prototype.is$Element = function(){return this;};
 Element.prototype.get$name = function() { return this.name; };
+Element.prototype.get$kind = function() { return this.kind; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 Element.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 Element.prototype.hashCode$0 = function() {
   return this.hashCode();
 };
 // ********** Code for VariableElement **************
 function VariableElement(node, typeAnnotation, name, enclosingElement) {
   this.node = node;
   this.typeAnnotation = typeAnnotation;
   Element.call(this, name, const$260, enclosingElement);
   // Initializers done
 }
 $inherits(VariableElement, Element);
+VariableElement.prototype.get$type = function() { return this.type; };
+VariableElement.prototype.set$type = function(value) { return this.type = value; };
 VariableElement.prototype.parseNode = function(canceler, logger) {
   return this.node;
 }
 VariableElement.prototype.computeType = function(compiler, types) {
   return getType(this.typeAnnotation, types);
 }
 VariableElement.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 // ********** Code for ForeignElement **************
 function ForeignElement(name) {
   Element.call(this, name, const$242, null);
   // Initializers done
 }
 $inherits(ForeignElement, Element);
 ForeignElement.prototype.computeType = function(compiler, types) {
   return types.dynamicType;
 }
 ForeignElement.prototype.computeType$2 = function($0, $1) {
   return this.computeType(($0 && $0.is$Compiler()), ($1 && $1.is$Types()));
 };
 // ********** Code for FunctionElement **************
 function FunctionElement(name) {
   Element.call(this, name, const$239, null);
   // Initializers done
 }
 $inherits(FunctionElement, Element);
+FunctionElement.prototype.get$type = function() { return this.type; };
+FunctionElement.prototype.set$type = function(value) { return this.type = value; };
 FunctionElement.prototype.computeType = function(compiler, types) {
   var $0;
   if (this.type != null) return (($0 = this.type) && $0.is$FunctionType());
   var node = (($0 = this.parseNode(compiler, compiler)) && $0.is$FunctionExpression());
   var returnType = getType(node.returnType, types);
   if (returnType == null) compiler.cancel(('unknown type ' + returnType + ''));
   var parameterTypes = new LinkBuilderImplementation();
   for (var link = node.parameters.nodes;
    !$notnull_bool(link.isEmpty$0()); link = link.get$tail()) {
     var parameter = (($0 = link.get$head()) && $0.is$VariableDefinitions());
     parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return (($0 = this.type) && $0.is$FunctionType());
 }
 FunctionElement.prototype.computeType$2 = FunctionElement.prototype.computeType;
 // ********** Code for ClassElement **************
 function ClassElement(name) {
   this.interfaces = const$14/*const EmptyLink()*/
   this.isResolved = false
   Element.call(this, name, const$237, null);
   // Initializers done
 }
 $inherits(ClassElement, Element);
 ClassElement.prototype.is$ClassElement = function(){return this;};
+ClassElement.prototype.get$type = function() { return this.type; };
+ClassElement.prototype.set$type = function(value) { return this.type = value; };
 ClassElement.prototype.get$interfaces = function() { return this.interfaces; };
 ClassElement.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 ClassElement.prototype.computeType = function(compiler, types) {
   if (this.type == null) {
     this.type = new SimpleType(this.name, this);
   }
   return this.type;
 }
 ClassElement.prototype.resolve = function(compiler) {
   if ($notnull_bool(this.isResolved)) return;
   compiler.resolveType(this);
   this.isResolved = true;
 }
 ClassElement.prototype.computeType$2 = ClassElement.prototype.computeType;
 ClassElement.prototype.resolve$1 = function($0) {
   return this.resolve(($0 && $0.is$Compiler()));
 };
 // ********** Code for top level **************
 function getType(annotation, types) {
   var $0;
   if (annotation == null || annotation.typeName == null) {
-    return (($0 = types.dynamicType) && $0.is$Type());
+    return (($0 = types.get$dynamicType()) && $0.is$Type());
   }
   return (($0 = types.lookup$1(annotation.typeName.get$source())) && $0.is$Type());
 }
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
 function SsaBuilderTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaBuilderTask, CompilerTask);
@@ skipping 904 matching lines @@
   this.dominator = null
   this.id = id;
   this.predecessors = [];
   this.successors = const$13/*const []*/;
   this.dominatedBlocks = [];
   // Initializers done
 }
 HBasicBlock.withId$ctor.prototype = HBasicBlock.prototype;
 $inherits(HBasicBlock, HInstructionList);
 HBasicBlock.prototype.is$HBasicBlock = function(){return this;};
+HBasicBlock.prototype.get$id = function() { return this.id; };
+HBasicBlock.prototype.set$id = function(value) { return this.id = value; };
 HBasicBlock.prototype.isNew = function() {
   return this.status == 0/*HBasicBlock.STATUS_NEW*/;
 }
 HBasicBlock.prototype.isOpen = function() {
   return this.status == 1/*HBasicBlock.STATUS_OPEN*/;
 }
 HBasicBlock.prototype.isClosed = function() {
   return this.status == 2/*HBasicBlock.STATUS_CLOSED*/;
 }
+HBasicBlock.prototype.get$isClosed = function() {
+  return HBasicBlock.prototype.isClosed.bind(this);
+}
 HBasicBlock.prototype.open = function() {
   $assert(this.isNew(), "isNew()", "nodes.dart", 256, 12);
   this.status = 1/*HBasicBlock.STATUS_OPEN*/;
 }
 HBasicBlock.prototype.close = function(end) {
   $assert(this.isOpen(), "isOpen()", "nodes.dart", 261, 12);
   this.addAfter(this.last, end);
   this.status = 2/*HBasicBlock.STATUS_CLOSED*/;
 }
 HBasicBlock.prototype.assignInstructionIds = function(id) {
@@ skipping 46 matching lines @@
   }
 }
 HBasicBlock.prototype.isExitBlock = function() {
   return this.first === this.last && (this.first instanceof HExit);
 }
 HBasicBlock.prototype.addDominatedBlock = function(block) {
   $assert(this.isClosed(), "isClosed()", "nodes.dart", 340, 12);
   $assert(this.id != null && block.id != null, "id !== null && block.id !== null", "nodes.dart", 341, 12);
   $assert(this.dominatedBlocks.indexOf(block) < 0, "dominatedBlocks.indexOf(block) < 0", "nodes.dart", 342, 12);
   var index = this.dominatedBlocks.length;
-  while (index > 0 && this.dominatedBlocks.$index(index - 1).id > block.id) {
+  while (index > 0 && this.dominatedBlocks.$index(index - 1).get$id() > block.id) {
     index--;
   }
   if (index == this.dominatedBlocks.length) {
     this.dominatedBlocks.add(block);
   }
   else {
     this.dominatedBlocks.insertRange(index, 1, block);
   }
   $assert(block.dominator == null, "block.dominator === null", "nodes.dart", 355, 12);
   block.dominator = this;
@@ skipping 55 matching lines @@
 function HInstruction(inputs) {
   this._usedBy = null
   this.previous = null
   this.next = null
   this.flags = 0
   this.inputs = inputs;
   // Initializers done
   this.prepareGvn();
 }
 HInstruction.prototype.is$HInstruction = function(){return this;};
+HInstruction.prototype.get$id = function() { return this.id; };
+HInstruction.prototype.set$id = function(value) { return this.id = value; };
+HInstruction.prototype.get$inputs = function() { return this.inputs; };
+HInstruction.prototype.get$previous = function() { return this.previous; };
+HInstruction.prototype.set$previous = function(value) { return this.previous = value; };
 HInstruction.prototype.getFlag = function(position) {
   return (this.flags & (1 << position)) != 0;
 }
 HInstruction.prototype.setFlag = function(position) {
   this.flags |= (1 << position);
 }
 HInstruction.prototype.getChangesFlags = function() {
   return this.flags & (1)/*((1 << FLAG_CHANGES_COUNT) - 1)*/;
 }
 HInstruction.prototype.hasSideEffects = function() {
@@ skipping 23 matching lines @@
 }
 HInstruction.prototype.isInBasicBlock = function() {
   return this._usedBy != null;
 }
 HInstruction.prototype.notifyAddedToBlock = function() {
   $assert(!$notnull_bool(this.isInBasicBlock()), "!isInBasicBlock()", "nodes.dart", 507, 12);
   this._usedBy = [];
   for (var i = 0;
    i < this.inputs.length; i++) {
     $assert(this.inputs.$index(i).isInBasicBlock$0(), "inputs[i].isInBasicBlock()", "nodes.dart", 511, 14);
-    this.inputs.$index(i).get$usedBy().add(this);
+    this.inputs.$index(i).get$usedBy().add$1(this);
   }
   $assert(this.isValid(), "isValid()", "nodes.dart", 514, 12);
 }
 HInstruction.prototype.notifyRemovedFromBlock = function() {
+  var $0;
   $assert(this.isInBasicBlock(), "isInBasicBlock()", "nodes.dart", 518, 12);
   $assert(this.get$usedBy().isEmpty(), "usedBy.isEmpty()", "nodes.dart", 519, 12);
   for (var i = 0;
    i < this.inputs.length; i++) {
-    var inputUsedBy = this.inputs.$index(i).get$usedBy();
+    var inputUsedBy = (($0 = this.inputs.$index(i).get$usedBy()) && $0.is$List());
     for (var j = 0;
      j < inputUsedBy.length; j++) {
       if (inputUsedBy.$index(j) === this) {
         inputUsedBy.$setindex(j, inputUsedBy.$index(inputUsedBy.length - 1));
         inputUsedBy.removeLast();
         break;
       }
     }
   }
   this._usedBy = null;
@@ skipping 66 matching lines @@
 HInvoke.prototype.toString$0 = function() {
   return this.toString();
 };
 // ********** Code for HInvokeForeign **************
 function HInvokeForeign(element, inputs, code) {
   this.code = code;
   HInvoke.call(this, element, inputs);
   // Initializers done
 }
 $inherits(HInvokeForeign, HInvoke);
+HInvokeForeign.prototype.get$code = function() { return this.code; };
 HInvokeForeign.prototype.accept = function(visitor) {
   return visitor.visitInvokeForeign(this);
 }
 HInvokeForeign.prototype.accept$1 = function($0) {
   return this.accept(($0 && $0.is$HVisitor()));
 };
 // ********** Code for HArithmetic **************
 function HArithmetic(element, inputs) {
   HInvoke.call(this, element, inputs);
   // Initializers done
@@ skipping 411 matching lines @@
 SsaInstructionMerger.prototype.visitGraph = function(graph) {
   this.visitDominatorTree(graph);
 }
 SsaInstructionMerger.prototype.visitInstruction = function(node) {
   var inputs = node.inputs;
   var previousUnused = node.previous;
   for (var i = inputs.length - 1;
    i >= 0; i--) {
     if (previousUnused == null) return;
     if ((previousUnused instanceof HPhi)) return;
-    if (inputs.$index(i).get$usedBy().length != 1) return;
+    if ($notnull_bool($ne(inputs.$index(i).get$usedBy().length, 1))) return;
     if (inputs.$index(i) !== previousUnused) return;
     inputs.$index(i).setGenerateAtUseSite$0();
     previousUnused = previousUnused.previous;
   }
 }
 // ********** Code for HTracer **************
 function HTracer() {}
 HTracer._internal$ctor = function() {
   this.indent = 0
   this.output = new StringBufferImpl("");
@@ skipping 301 matching lines @@
   var result = 0;
   for (var i = 0;
    i < instructions.length; i++) {
     if (instructions.$index(i) === instruction) result++;
   }
   return result;
 }
 HValidator.everyInstruction = function(instructions, f) {
   var copy = ListFactory.ListFactory$from$factory(instructions);
   for (var i = 0;
-   i < copy.length; i++) {
+   i < $assert_num(copy.length); i++) {
     var current = copy.$index(i);
     if (current == null) continue;
     var count = 1;
     for (var j = i + 1;
-     j < copy.length; j++) {
+     j < $assert_num(copy.length); j++) {
       if (copy.$index(j) === current) {
         copy.$setindex(j);
         count++;
       }
     }
     if (!$notnull_bool(f.call$2(current, count))) return false;
   }
   return true;
 }
 HValidator.prototype.visitInstruction = function(instruction) {
   var $this = this; // closure support
   function hasCorrectInputs(instruction) {
+    var $0;
     var inBasicBlock = $assert_bool(instruction.isInBasicBlock$0());
-    return HValidator.everyInstruction(instruction.inputs, (function (input, count) {
+    return HValidator.everyInstruction((($0 = instruction.get$inputs()) && $0.is$List$HInstruction()), (function (input, count) {
+      var $0;
       if ($notnull_bool(inBasicBlock)) {
-        return HValidator.countInstruction(input.get$usedBy(), (instruction && instruction.is$HInstruction())) == count;
+        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == count;
       }
       else {
-        return HValidator.countInstruction(input.get$usedBy(), (instruction && instruction.is$HInstruction())) == 0;
+        return HValidator.countInstruction((($0 = input.get$usedBy()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == 0;
       }
     })
     );
   }
   function hasCorrectUses(instruction) {
+    var $0;
     if (!$notnull_bool(instruction.isInBasicBlock$0())) return true;
-    return HValidator.everyInstruction(instruction.get$usedBy(), (function (use, count) {
-      return HValidator.countInstruction(use.inputs, (instruction && instruction.is$HInstruction())) == count;
+    return HValidator.everyInstruction((($0 = instruction.get$usedBy()) && $0.is$List$HInstruction()), (function (use, count) {
+      var $0;
+      return HValidator.countInstruction((($0 = use.get$inputs()) && $0.is$List$HInstruction()), (instruction && instruction.is$HInstruction())) == count;
     })
     );
   }
   this.isValid = $notnull_bool($notnull_bool(this.isValid && hasCorrectInputs(instruction)) && hasCorrectUses(instruction));
 }
 // ********** Code for ValueSetNode **************
 function ValueSetNode() {}
 ValueSetNode.prototype.get$value = function() { return this.value; };
 ValueSetNode.prototype.next$0 = function() {
   return this.next();
@@ skipping 10 matching lines @@
 WorldCompiler.prototype.log = function(message) {
   if ($notnull_bool(options.showInfo)) {
     this.world.info(('[leg] ' + message + ''));
   }
 }
 WorldCompiler.prototype.run = function() {
   var success = Compiler.prototype.run.call(this);
   if ($notnull_bool(success)) {
     var code = this.getGeneratedCode();
     this.world.legCode = $assert_String(code);
-    this.world.jsBytesWritten = code.length;
+    this.world.jsBytesWritten = $assert_num(code.length);
     var $list = this.tasks;
     for (var $i0 = 0;$i0 < $list.length; $i0++) {
       var task = $list.$index($i0);
       this.log(('' + task.get$name() + ' took ' + task.get$timing() + 'msec'));
     }
   }
   return success;
 }
 WorldCompiler.prototype.spanFromNode = function(node) {
   var begin = node.getBeginToken();
@@ skipping 18 matching lines @@
   this.scanner = new ScannerTask(this);
   this.parser = new ParserTask(this);
   this.resolver = new ResolverTask(this);
   this.checker = new TypeCheckerTask(this);
   this.builder = new SsaBuilderTask(this);
   this.optimizer = new SsaOptimizerTask(this);
   this.generator = new SsaCodeGeneratorTask(this);
   this.tasks = [this.scanner, this.parser, this.resolver, this.checker, this.builder, this.optimizer, this.generator];
 }
 Compiler.prototype.is$Compiler = function(){return this;};
+Compiler.prototype.get$generator = function() { return this.generator; };
+Compiler.prototype.set$generator = function(value) { return this.generator = value; };
 Compiler.prototype.ensure = function(condition) {
   if (!$notnull_bool(condition)) this.cancel('failed assertion in leg');
 }
 Compiler.prototype.unimplemented = function(methodName) {
   this.cancel(("" + methodName + " not implemented"));
 }
 Compiler.prototype.cancel = function(reason) {
   $throw(new CompilerCancelledException(reason));
 }
 Compiler.prototype.log = function(message) {
@@ skipping 428 matching lines @@
   return this.add(($0 && $0.is$Element()));
 };
 TopScope.prototype.lookup$1 = function($0) {
   return this.lookup(($0 && $0.is$SourceString()));
 };
 // ********** Code for leg_Script **************
 function leg_Script(file) {
   this.file = file;
   // Initializers done
 }
+leg_Script.prototype.get$file = function() { return this.file; };
 leg_Script.prototype.get$text = function() {
   return this.file.get$text();
 }
 // ********** Code for TypeCheckerTask **************
 function TypeCheckerTask(compiler) {
   this.types = new Types();
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(TypeCheckerTask, CompilerTask);
 TypeCheckerTask.prototype.get$name = function() {
   return "Type checker";
 }
+TypeCheckerTask.prototype.get$types = function() { return this.types; };
+TypeCheckerTask.prototype.set$types = function(value) { return this.types = value; };
 TypeCheckerTask.prototype.check = function(tree, elements) {
   var $this = this; // closure support
   this.measure((function () {
     var visitor = new TypeCheckerVisitor($this.compiler, elements, $this.types);
     try {
       tree.accept(visitor);
     } catch (e) {
       e = $toDartException(e);
       if (!(e instanceof CancelTypeCheckException)) throw e;
       $this.compiler.reportWarning(e.node, e.reason);
@@ skipping 61 matching lines @@
 };
 // ********** Code for Types **************
 function Types() {
   this.voidType = new SimpleType.named$ctor(const$4/*Types.VOID*/);
   this.intType = new SimpleType.named$ctor(const$6/*Types.INT*/);
   this.dynamicType = new SimpleType.named$ctor(const$8/*Types.DYNAMIC*/);
   this.stringType = new SimpleType.named$ctor(const$10/*Types.STRING*/);
   // Initializers done
 }
 Types.prototype.is$Types = function(){return this;};
+Types.prototype.get$dynamicType = function() { return this.dynamicType; };
 Types.prototype.lookup = function(s) {
   if ($notnull_bool($eq(const$4/*Types.VOID*/, s))) {
     return this.voidType;
   }
   else if ($notnull_bool($eq(const$6/*Types.INT*/, s))) {
     return this.intType;
   }
   else if ($notnull_bool($eq(const$8/*Types.DYNAMIC*/, s) || s.get$stringValue() === 'var')) {
     return this.dynamicType;
   }
@@ skipping 18 matching lines @@
   // Initializers done
 }
 // ********** Code for TypeCheckerVisitor **************
 function TypeCheckerVisitor(compiler, elements, types) {
   this.compiler = compiler;
   this.elements = elements;
   this.types = types;
   // Initializers done
 }
 TypeCheckerVisitor.prototype.is$Visitor = function(){return this;};
+TypeCheckerVisitor.prototype.get$types = function() { return this.types; };
+TypeCheckerVisitor.prototype.set$types = function(value) { return this.types = value; };
 TypeCheckerVisitor.prototype.fail = function(node, reason) {
   var message = 'cannot type-check';
   if (reason != null) {
     message = ('' + message + ': ' + reason + '');
   }
   $throw(new CancelTypeCheckException(node, message));
 }
 TypeCheckerVisitor.prototype.nonVoidType = function(node) {
   var type = this.type(node);
   if ($eq(type, this.types.voidType)) {
     this.compiler.reportWarning(node, CompilerError.voidExpression());
   }
   return type;
 }
 TypeCheckerVisitor.prototype.typeWithDefault = function(node, defaultValue) {
   return node != null ? this.type(node) : defaultValue;
 }
 TypeCheckerVisitor.prototype.type = function(node) {
   var $0;
   if (node == null) this.fail(null, 'unexpected node: null');
   var result = (($0 = node.accept(this)) && $0.is$Type());
   return result;
 }
+TypeCheckerVisitor.prototype.get$type = function() {
+  return TypeCheckerVisitor.prototype.type.bind(this);
+}
 TypeCheckerVisitor.prototype.checkAssignable = function(node, s, t) {
   if (!$notnull_bool(this.types.isAssignable(s, t))) {
     var error = CompilerError.notAssignable(s, t);
     this.compiler.reportWarning(node, error);
   }
 }
 TypeCheckerVisitor.prototype.visitBlock = function(node) {
   this.type(node.statements);
   return this.types.voidType;
 }
@@ skipping 369 matching lines @@
   this.main.declaringType.markUsed();
   world.corelib.types.$index('BadNumberFormatException').markUsed$0();
   world.get$coreimpl().types.$index('NumImplementation').markUsed$0();
   world.get$coreimpl().types.$index('StringImplementation').markUsed$0();
   world.get$coreimpl().types.$index('MatchImplementation').markUsed$0();
   this.genMethod((($0 = world.get$coreimpl().types.$index('MatchImplementation').getConstructor$1('')) && $0.is$Member()));
   this.writeTypes(world.get$coreimpl());
   this.writeTypes(world.corelib);
   this.writeTypes(this.main.declaringType.get$library());
   this._writeGlobals();
-  this.writer.writeln(('RunEntry(function () {' + mainCall.code + ';}, []);'));
+  this.writer.writeln(('RunEntry(function () {' + mainCall.get$code() + ';}, []);'));
 }
 WorldGenerator.prototype.globalForStaticField = function(field, fieldValue, dependencies) {
   var $0;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
   if (!this.globals.containsKey(fullname)) {
     this.globals.$setindex(fullname, GlobalValue.GlobalValue$fromStatic$factory(field, fieldValue, dependencies));
   }
   return (($0 = this.globals.$index(fullname)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.globalForConst = function(exp, dependencies) {
   var $0;
   var code = exp.canonicalCode;
   if (!this.globals.containsKey(code)) {
     this.globals.$setindex(code, GlobalValue.GlobalValue$fromConst$factory(this.globals.get$length(), exp, dependencies));
   }
   return (($0 = this.globals.$index(code)) && $0.is$GlobalValue());
 }
 WorldGenerator.prototype.writeTypes = function(lib) {
+  var $0;
   if ($notnull_bool(lib.isWritten)) return;
   lib.isWritten = true;
   var $list = lib.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var import_ = $list.$index($i);
-    this.writeTypes(import_.get$library());
+    this.writeTypes((($0 = import_.get$library()) && $0.is$Library()));
   }
   for (var i = 0;
    i < lib.sources.length; i++) {
-    lib.sources.$index(i).orderInLibrary = i;
+    lib.sources.$index(i).set$orderInLibrary(i);
   }
   this.writer.comment(('//  ********** Library ' + lib.name + ' **************'));
   if ($notnull_bool(lib.get$isCore())) {
     this.writer.comment('//  ********** Natives dart:core **************');
     this.corejs.generate(this.writer);
   }
   var $list = lib.natives;
   for (var $i = 0;$i < $list.length; $i++) {
     var file = $list.$index($i);
-    var filename = basename(file.filename);
+    var filename = basename($assert_String(file.get$filename()));
     this.writer.comment(('//  ********** Natives ' + filename + ' **************'));
-    this.writer.writeln(file.get$text());
+    this.writer.writeln($assert_String(file.get$text()));
   }
   lib.topType.markUsed();
   var $list = this._orderValues(lib.types);
   for (var $i = 0;$i < $list.length; $i++) {
     var type = $list.$index($i);
     if ($notnull_bool(type.get$isUsed() && type.get$isClass())) {
       this.writeType((type && type.is$lang_Type()));
       if ($notnull_bool(type.get$isGeneric())) {
         var $list0 = this._orderValues(type._concreteTypes);
         for (var $i0 = 0;$i0 < $list0.length; $i0++) {
           var ct = $list0.$index($i0);
           this.writeType((ct && ct.is$lang_Type()));
         }
       }
     }
-    if ($notnull_bool(type.get$isFunction() && type.varStubs != null)) {
+    if ($notnull_bool(type.get$isFunction() && $ne(type.get$varStubs(), null))) {
       this.writer.comment(('// ********** Code for ' + type.get$jsname() + ' **************'));
       this._writeDynamicStubs((type && type.is$lang_Type()));
     }
-    if (type.typeCheckCode != null) {
-      this.writer.writeln(type.typeCheckCode);
+    if ($notnull_bool($ne(type.get$typeCheckCode(), null))) {
+      this.writer.writeln($assert_String(type.get$typeCheckCode()));
     }
   }
 }
 WorldGenerator.prototype.genMethod = function(meth, enclosingMethod) {
   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;
@@ skipping 33 matching lines @@
       if (!$notnull_bool(type.get$isNativeType())) {
         this.writer.writeln(('function ' + type.get$jsname() + '() {}'));
       }
     }
     else {
       standardConstructor.generator.writeDefinition(this.writer, null);
     }
     var $list = type.get$constructors().getValues();
     for (var $i = type.get$constructors().getValues().iterator$0(); $i.hasNext$0(); ) {
       var c = $i.next$0();
-      if ($notnull_bool($ne(c.generator, null) && $ne(c, standardConstructor))) {
-        c.generator.writeDefinition$2(this.writer);
+      if ($notnull_bool($ne(c.get$generator(), null) && $ne(c, standardConstructor))) {
+        c.get$generator().writeDefinition$2(this.writer);
       }
     }
   }
   if (!$notnull_bool(type.get$isTop())) {
     if ((type instanceof ConcreteType)) {
       this._ensureInheritsHelper();
       this.writer.writeln(('\$inherits(' + type.get$jsname() + ', ' + type.get$genericType().get$jsname() + ');'));
     }
     else if (!$notnull_bool(type.get$isNativeType())) {
       if (type.get$parent() != null && !$notnull_bool(type.get$parent().get$isObject())) {
@@ skipping 12 matching lines @@
       this._maybeIsTest(type, (ct && ct.is$lang_Type()));
     }
   }
   if (type.get$interfaces() != null) {
     var seen = new HashSetImplementation();
     var worklist = [];
     worklist.addAll(type.get$interfaces());
     seen.addAll(type.get$interfaces());
     while (!worklist.isEmpty()) {
       var interface_ = worklist.removeLast();
-      this._maybeIsTest(type, interface_.get$genericType());
+      this._maybeIsTest(type, (($0 = interface_.get$genericType()) && $0.is$lang_Type()));
       if (interface_.get$genericType()._concreteTypes != null) {
         var $list = this._orderValues(interface_.get$genericType()._concreteTypes);
         for (var $i = 0;$i < $list.length; $i++) {
           var ct = $list.$index($i);
           this._maybeIsTest(type, (ct && ct.is$lang_Type()));
         }
       }
       var $list = interface_.get$interfaces();
       for (var $i = interface_.get$interfaces().iterator$0(); $i.hasNext$0(); ) {
         var other = $i.next$0();
@@ skipping 33 matching lines @@
       stub.generate$1(this.writer);
     }
   }
 }
 WorldGenerator.prototype._writeStaticField = function(field) {
   if ($notnull_bool(field.isFinal)) return;
   var fullname = ("" + field.declaringType.get$jsname() + "." + field.get$jsname() + "");
   if (this.globals.containsKey(fullname)) {
     var value = this.globals.$index(fullname);
     if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative))) {
-      this.writer.writeln(('var ' + field.get$jsname() + ' = ' + value.exp.code + ';'));
+      this.writer.writeln(('var ' + field.get$jsname() + ' = ' + value.get$exp().get$code() + ';'));
     }
     else {
-      this.writer.writeln(('' + field.declaringType.get$jsname() + '.' + field.get$jsname() + ' = ' + value.exp.code + ';'));
+      this.writer.writeln(('' + field.declaringType.get$jsname() + '.' + field.get$jsname() + ' = ' + value.get$exp().get$code() + ';'));
     }
   }
 }
 WorldGenerator.prototype._writeField = function(field) {
   if ($notnull_bool(field.declaringType.get$isTop() && !$notnull_bool(field.isNative)) && field.value == null) {
     this.writer.writeln(('var ' + field.get$jsname() + ';'));
   }
   if ($notnull_bool(field._providePropertySyntax)) {
     this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.get\$' + field.get$jsname() + ' = ') + ('function() { return this.' + field.get$jsname() + '; };'));
     if (!$notnull_bool(field.isFinal)) {
@@ skipping 18 matching lines @@
 }
 WorldGenerator.prototype._writeMethod = function(method) {
   if (method.generator != null) {
     method.generator.writeDefinition(this.writer, null);
   }
 }
 WorldGenerator.prototype.get$_writeMethod = function() {
   return WorldGenerator.prototype._writeMethod.bind(this);
 }
 WorldGenerator.prototype._writeGlobals = function() {
+  var $0;
   if (this.globals.get$length() > 0) {
     this.writer.comment('//  ********** Globals **************');
   }
   var list = this.globals.getValues();
   list.sort$1((function (a, b) {
     return a.compareTo$1(b);
   })
   );
   for (var $i = list.iterator$0(); $i.hasNext$0(); ) {
     var global = $i.next$0();
-    if (global.field != null) {
-      this._writeStaticField(global.field);
+    if ($notnull_bool($ne(global.get$field(), null))) {
+      this._writeStaticField((($0 = global.get$field()) && $0.is$FieldMember()));
     }
     else {
-      this.writer.writeln(('var ' + global.get$name() + ' = ' + global.exp.code + ';'));
+      this.writer.writeln(('var ' + global.get$name() + ' = ' + global.get$exp().get$code() + ';'));
     }
   }
 }
 WorldGenerator.prototype._orderValues = function(map) {
   var $0;
   var values = (($0 = map.getValues()) && $0.is$List());
   values.sort(this.get$_compareMembers());
   return values;
 }
 WorldGenerator.prototype._compareMembers = function(x, y) {
-  if (x.get$span() != null && y.get$span() != null) {
-    var spans = x.get$span().compareTo(y.get$span());
+  if ($notnull_bool($ne(x.get$span(), null) && $ne(y.get$span(), null))) {
+    var spans = $assert_num(x.get$span().compareTo$1(y.get$span()));
     if (spans != 0) return spans;
   }
-  if (x.get$span() == null) return 1;
-  if (y.get$span() == null) return -1;
+  if ($notnull_bool(x.get$span() == null)) return 1;
+  if ($notnull_bool(y.get$span() == null)) return -1;
   return $assert_num(x.get$name().compareTo$1(y.get$name()));
 }
 WorldGenerator.prototype.get$_compareMembers = function() {
   return WorldGenerator.prototype._compareMembers.bind(this);
 }
 WorldGenerator.prototype.useMapFactory = function() {
   var $0;
   this.corejs.useMap = true;
   var factType = world.get$coreimpl().types.$index('HashMapImplementation');
   var m = factType.resolveMember$1('\$setindex');
@@ skipping 10 matching lines @@
   this._vars = $map([]);
   // Initializers done
   if ($notnull_bool(this.get$isMethodScope())) {
     this._closedOver = new HashSetImplementation();
   }
   else {
     this.reentrant = $notnull_bool(this.reentrant || this.parent.reentrant);
   }
 }
 BlockScope.prototype.is$BlockScope = function(){return this;};
+BlockScope.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
+BlockScope.prototype.set$enclosingMethod = function(value) { return this.enclosingMethod = value; };
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = value; };
+BlockScope.prototype.get$rethrow = function() { return this.rethrow; };
+BlockScope.prototype.set$rethrow = function(value) { return this.rethrow = value; };
+BlockScope.prototype.get$reentrant = function() { return this.reentrant; };
+BlockScope.prototype.set$reentrant = function(value) { return this.reentrant = 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();
   return (s && s.is$BlockScope());
 }
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($notnull_bool($ne(ret, null))) return ret;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
     ret = s._vars.$index(name);
     if ($notnull_bool($ne(ret, null))) {
-      if ($ne(s.enclosingMethod, this.enclosingMethod)) {
-        s.get$methodScope()._closedOver.add(ret.code);
-        if ($notnull_bool(this.enclosingMethod.captures != null && s.reentrant)) {
-          this.enclosingMethod.captures.add(ret.code);
+      if ($notnull_bool($ne(s.get$enclosingMethod(), this.enclosingMethod))) {
+        s.get$methodScope()._closedOver.add(ret.get$code());
+        if ($notnull_bool(this.enclosingMethod.captures != null && s.get$reentrant())) {
+          this.enclosingMethod.captures.add(ret.get$code());
         }
       }
       return ret;
     }
   }
 }
 BlockScope.prototype._isDefinedInParent = function(name) {
   if ($notnull_bool(this.get$isMethodScope() && this._closedOver.contains(name))) return true;
   for (var s = this.parent;
    $notnull_bool($ne(s, null)); s = s.get$parent()) {
@@ skipping 20 matching lines @@
   return (ret && ret.is$Value());
 }
 BlockScope.prototype.declareParameter = function(p) {
   return this.create(p.name, p.type, p.definition.span, true);
 }
 BlockScope.prototype.declare = function(id) {
   var type = this.enclosingMethod.method.resolveType(id.type, false);
   return this.create(id.name.name, (type && type.is$lang_Type()), id.span, false);
 }
 BlockScope.prototype.getRethrow = function() {
+  var $0;
   var scope = this;
-  while ($notnull_bool(scope.rethrow == null && $ne(scope.get$parent(), null))) {
+  while ($notnull_bool(scope.get$rethrow() == null && $ne(scope.get$parent(), null))) {
     scope = scope.get$parent();
   }
-  return scope.rethrow;
+  return (($0 = scope.get$rethrow()) && $0.is$Value());
 }
 BlockScope.prototype.lookup$1 = function($0) {
   return this.lookup($assert_String($0));
 };
 // ********** Code for MethodGenerator **************
 function MethodGenerator(method, enclosingMethod) {
   var $0;
   this.method = method;
   this.enclosingMethod = enclosingMethod;
   this.writer = new CodeWriter();
   this.needsThis = false;
   // Initializers done
   if (this.enclosingMethod != null) {
     this._scope = new BlockScope(this, this.enclosingMethod._scope, false);
     this.captures = new HashSetImplementation();
   }
   else {
     this._scope = new BlockScope(this, null, false);
   }
   if (this.enclosingMethod != null && this.method.name != '') {
     var m = (($0 = this.method) && $0.is$MethodMember());
     this._scope.create(m.name, m.get$functionType(), m.definition.span, false);
   }
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
 MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.is$TreeVisitor = function(){return this;};
+MethodGenerator.prototype.get$enclosingMethod = function() { return this.enclosingMethod; };
+MethodGenerator.prototype.set$enclosingMethod = function(value) { return this.enclosingMethod = value; };
+MethodGenerator.prototype.get$needsThis = function() { return this.needsThis; };
+MethodGenerator.prototype.set$needsThis = function(value) { return this.needsThis = value; };
 MethodGenerator.prototype.get$library = function() {
   return this.method.get$library();
 }
 MethodGenerator.prototype.findMembers = function(name) {
   return this.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
 MethodGenerator.prototype.get$isStatic = function() {
@@ skipping 26 matching lines @@
     this._freeTemps.add(value.code);
   }
   else {
     world.internalError(('tried to free unused value or non-temp "' + value.code + '"'));
   }
 }
 MethodGenerator.prototype.run = function() {
   if ($notnull_bool(this.method.isGenerated)) return;
   this.method.isGenerated = true;
   this.method.generator = this;
-  if ((this.method.get$definition().body instanceof NativeStatement)) {
-    if ($notnull_bool(this.method.get$definition().body.body == null)) {
+  if ((this.method.get$definition().get$body() instanceof NativeStatement)) {
+    if ($notnull_bool(this.method.get$definition().get$body().get$body() == null)) {
       this.method.generator = null;
     }
     else {
       this._paramCode = map(this.method.get$parameters(), (function (p) {
         return p.get$name();
       })
       );
-      this.writer.write($assert_String(this.method.get$definition().body.body));
+      this.writer.write($assert_String(this.method.get$definition().get$body().get$body()));
     }
   }
   else {
     this.writeBody();
   }
 }
 MethodGenerator.prototype.writeDefinition = function(defWriter, lambda) {
   var $0;
   var paramCode = this._paramCode;
   var names = null;
@@ skipping 88 matching lines @@
     var meth = (($0 = this.method) && $0.is$MethodMember());
     if ($notnull_bool(meth._provideOptionalParamInfo)) {
       var optNames = [];
       var optValues = [];
       meth.genParameterValues();
       var $list = meth.parameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var param = $list.$index($i);
         if ($notnull_bool(param.get$isOptional())) {
           optNames.add$1(param.get$name());
-          optValues.add$1(MethodGenerator._escapeString($assert_String(param.get$value().code)));
+          optValues.add$1(MethodGenerator._escapeString($assert_String(param.get$value().get$code())));
         }
       }
       if (optNames.length > 0) {
         var start = '';
         if ($notnull_bool(meth.isStatic)) {
           if (!$notnull_bool(meth.declaringType.get$isTop())) {
             start = meth.declaringType.get$jsname() + '.';
           }
         }
         else {
           start = meth.declaringType.get$jsname() + '.prototype.';
         }
         optNames.addAll$1(optValues);
         var optional = "['" + Strings.join((optNames && optNames.is$List$String()), "', '") + "']";
         defWriter.writeln(('' + start + '' + meth.get$jsname() + '.\$optional = ' + optional + ''));
       }
     }
   }
 }
 MethodGenerator.prototype.writeBody = function() {
+  var $0;
   var initializers = null;
   var initializedFields = null;
   if ($notnull_bool(this.method.get$isConstructor())) {
     initializers = [];
     initializedFields = new HashSetImplementation();
     var $list = world.gen._orderValues(this.method.declaringType.getAllMembers());
     for (var $i = 0;$i < $list.length; $i++) {
       var f = $list.$index($i);
       if ((f instanceof FieldMember) && !$notnull_bool(f.get$isStatic())) {
         var cv = f.computeValue$0();
         if ($notnull_bool($ne(cv, null))) {
-          initializers.add$1(('this.' + f.get$jsname() + ' = ' + cv.code + ''));
+          initializers.add$1(('this.' + f.get$jsname() + ' = ' + cv.get$code() + ''));
           initializedFields.add$1(f.get$name());
         }
       }
     }
   }
   this._paramCode = [];
   var $list = this.method.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
-    if ($notnull_bool($ne(initializers, null) && p.isInitializer)) {
+    if ($notnull_bool($ne(initializers, null) && p.get$isInitializer())) {
       var field = this.method.declaringType.getMember(p.get$name());
       if ($notnull_bool(field == null)) {
-        world.error('bad this parameter - no matching field', p.get$definition().get$span());
+        world.error('bad this parameter - no matching field', (($0 = p.get$definition().get$span()) && $0.is$SourceSpan()));
       }
       if (!$notnull_bool(field.get$isField())) {
-        world.error(('"this.' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
+        world.error(('"this.' + p.get$name() + '" does not refer to a field'), (($0 = p.get$definition().get$span()) && $0.is$SourceSpan()));
       }
       var paramValue = new Value(field.get$returnType(), p.get$name(), p.get$definition().get$span(), false);
-      this._paramCode.add(paramValue.code);
-      initializers.add$1(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
+      this._paramCode.add(paramValue.get$code());
+      initializers.add$1(('this.' + field.get$jsname() + ' = ' + paramValue.get$code() + ';'));
       initializedFields.add$1(p.get$name());
     }
     else {
       var paramValue = this._scope.declareParameter((p && p.is$Parameter()));
-      this._paramCode.add(paramValue.code);
+      this._paramCode.add(paramValue.get$code());
     }
   }
-  var body = this.method.get$definition().body;
+  var body = this.method.get$definition().get$body();
   if ($notnull_bool(body == null && !$notnull_bool(this.method.get$isConstructor()))) {
-    world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
+    world.error(('unexpected empty body for ' + this.method.name + ''), (($0 = this.method.get$definition().get$span()) && $0.is$SourceSpan()));
   }
   if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator$0(); $i.hasNext$0(); ) {
       var i = $i.next$0();
       this.writer.writeln($assert_String(i));
     }
-    var declaredInitializers = this.method.get$definition().initializers;
-    if (declaredInitializers != null) {
+    var declaredInitializers = this.method.get$definition().get$initializers();
+    if ($notnull_bool($ne(declaredInitializers, null))) {
       var initializerCall = null;
-      for (var $i = 0;$i < declaredInitializers.length; $i++) {
-        var init = declaredInitializers.$index($i);
+      for (var $i = declaredInitializers.iterator$0(); $i.hasNext$0(); ) {
+        var init = $i.next$0();
         if ((init instanceof CallExpression)) {
           if ($notnull_bool($ne(initializerCall, null))) {
-            world.error('only one initializer redirecting call is allowed', init.get$span());
+            world.error('only one initializer redirecting call is allowed', (($0 = init.get$span()) && $0.is$SourceSpan()));
           }
           initializerCall = init;
         }
-        else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign(init.op.kind) == 0) {
-          var left = init.x;
-          if (!((left instanceof DotExpression) && (left.self instanceof ThisExpression) || (left instanceof VarExpression))) {
-            world.error('invalid left side of initializer', left.get$span());
+        else if ((init instanceof BinaryExpression) && TokenKind.kindFromAssign($assert_num(init.get$op().get$kind())) == 0) {
+          var left = init.get$x();
+          if (!((left instanceof DotExpression) && (left.get$self() instanceof ThisExpression) || (left instanceof VarExpression))) {
+            world.error('invalid left side of initializer', (($0 = left.get$span()) && $0.is$SourceSpan()));
             continue;
           }
           var f = this.method.declaringType.getMember(left.get$name().get$name());
           if ($notnull_bool(f == null)) {
-            world.error('bad initializer - no matching field', left.get$span());
+            world.error('bad initializer - no matching field', (($0 = left.get$span()) && $0.is$SourceSpan()));
             continue;
           }
           else if (!$notnull_bool(f.get$isField())) {
-            world.error(('"' + left.get$name().get$name() + '" does not refer to a field'), left.get$span());
+            world.error(('"' + left.get$name().get$name() + '" does not refer to a field'), (($0 = left.get$span()) && $0.is$SourceSpan()));
             continue;
           }
           initializedFields.add$1(f.get$name());
-          this.writer.writeln(('this.' + f.get$jsname() + ' = ' + this.visitValue(init.y).code + ';'));
+          this.writer.writeln(('this.' + f.get$jsname() + ' = ' + this.visitValue((($0 = init.get$y()) && $0.is$lang_Expression())).get$code() + ';'));
         }
         else {
-          world.error('invalid initializer', init.get$span());
+          world.error('invalid initializer', (($0 = init.get$span()) && $0.is$SourceSpan()));
         }
       }
       if ($notnull_bool($ne(initializerCall, null))) {
         var target = this._writeInitializerCall((initializerCall && initializerCall.is$CallExpression()));
-        if (!$notnull_bool(target.isSuper)) {
+        if (!$notnull_bool(target.get$isSuper())) {
           if (initializers.length > 0) {
             var $list = this.method.get$parameters();
             for (var $i = 0;$i < $list.length; $i++) {
               var p = $list.$index($i);
-              if ($notnull_bool(p.isInitializer)) {
-                world.error('no initialization allowed on redirecting constructors', p.get$definition().get$span());
+              if ($notnull_bool(p.get$isInitializer())) {
+                world.error('no initialization allowed on redirecting constructors', (($0 = p.get$definition().get$span()) && $0.is$SourceSpan()));
                 break;
               }
             }
           }
           if (declaredInitializers.length > 1) {
-            var init = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
-            world.error('no initialization allowed on redirecting constructors', init.get$span());
+            var init0 = $notnull_bool($eq(declaredInitializers.$index(0), initializerCall)) ? declaredInitializers.$index(1) : declaredInitializers.$index(0);
+            world.error('no initialization allowed on redirecting constructors', (($0 = init0.get$span()) && $0.is$SourceSpan()));
           }
           initializedFields = null;
         }
       }
       else {
       }
     }
     this.writer.comment('// Initializers done');
   }
   if ($notnull_bool($ne(initializedFields, null))) {
     var $list = this.method.declaringType.get$members().getKeys();
     for (var $i = this.method.declaringType.get$members().getKeys().iterator$0(); $i.hasNext$0(); ) {
       var name = $i.next$0();
       var member = this.method.declaringType.get$members().$index(name);
-      if ($notnull_bool((member instanceof FieldMember) && member.isFinal) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains$1(name))) {
-        world.error(('Field "' + name + '" is final and was not initialized'), this.method.get$definition().get$span());
+      if ($notnull_bool((member instanceof FieldMember) && member.get$isFinal()) && !$notnull_bool(member.get$isStatic()) && !$notnull_bool(initializedFields.contains$1(name))) {
+        world.error(('Field "' + name + '" is final and was not initialized'), (($0 = this.method.get$definition().get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   this.visitStatementsInBlock((body && body.is$lang_Statement()));
 }
 MethodGenerator.prototype._writeInitializerCall = function(node) {
   var contructorName = '';
   var targetExp = node.target;
   if ((targetExp instanceof DotExpression)) {
     var dot = (targetExp && targetExp.is$DotExpression());
     targetExp = dot.self;
     contructorName = dot.name.name;
   }
   var target = null;
   if ((targetExp instanceof SuperExpression)) {
     target = this._makeSuperValue((targetExp && targetExp.is$lang_Node()));
   }
   else if ((targetExp instanceof ThisExpression)) {
     target = this._makeThisValue((targetExp && targetExp.is$lang_Node()));
   }
   else {
     world.error('bad call in initializers', node.span);
   }
-  var m = target.type.getConstructor$1(contructorName);
+  var m = target.get$type().getConstructor$1(contructorName);
   this.method.set$initDelegate(m);
   var other = m;
   while ($notnull_bool($ne(other, null))) {
     if ($notnull_bool($eq(other, this.method))) {
       world.error('initialization cycle', node.span);
       break;
     }
     other = other.get$initDelegate();
   }
   world.gen.genMethod((m && m.is$Member()));
   var value = m.invoke$4(this, node, target, this._makeArgs(node.arguments));
-  if ($notnull_bool($ne(target.type, world.objectType))) {
-    this.writer.writeln(('' + value.code + ';'));
+  if ($notnull_bool($ne(target.get$type(), world.objectType))) {
+    this.writer.writeln(('' + value.get$code() + ';'));
   }
   return (target && target.is$Value());
 }
 MethodGenerator.prototype._makeArgs = function(arguments) {
   var $0;
   var args = [];
   var seenLabel = false;
   for (var $i = 0;$i < arguments.length; $i++) {
     var arg = arguments.$index($i);
-    if (arg.label != null) {
+    if ($notnull_bool($ne(arg.get$label(), null))) {
       seenLabel = true;
     }
     else if ($notnull_bool(seenLabel)) {
-      world.error('bare argument can not follow named arguments', arg.get$span());
+      world.error('bare argument can not follow named arguments', (($0 = arg.get$span()) && $0.is$SourceSpan()));
     }
     args.add$1(this.visitValue((($0 = arg.get$value()) && $0.is$lang_Expression())));
   }
   return new Arguments(arguments, args);
 }
 MethodGenerator._escapeString = function(text) {
   return text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\n', '\\n').replaceAll('\r', '\\r');
 }
 MethodGenerator.prototype.visitStatementsInBlock = function(body) {
   if ((body instanceof BlockStatement)) {
@@ skipping 10 matching lines @@
   return false;
 }
 MethodGenerator.prototype._pushBlock = function(reentrant) {
   this._scope = new BlockScope(this, this._scope, reentrant);
 }
 MethodGenerator.prototype._popBlock = function() {
   this._scope = this._scope.parent;
 }
 MethodGenerator.prototype._makeLambdaMethod = function(name, func) {
   var meth = new MethodMember(name, this.method.declaringType, func);
-  meth.isLambda = true;
+  meth.set$isLambda(true);
   meth.resolve$1(this.method.declaringType);
   world.gen.genMethod((meth && meth.is$Member()), this);
   return (meth && meth.is$MethodMember());
 }
 MethodGenerator.prototype.visitBool = function(node) {
   return this.visitValue(node).convertTo$3(this, world.nonNullBool, node);
 }
 MethodGenerator.prototype.visitValue = function(node) {
   if (node == null) return null;
   var value = node.visit(this);
   value.checkFirstClass$1(node.span);
   return value;
 }
 MethodGenerator.prototype.visitTypedValue = function(node, expectedType) {
   return this.visitValue(node).convertTo$3(this, expectedType, node);
 }
 MethodGenerator.prototype.visitVoid = function(node) {
   if ((node instanceof PostfixExpression)) {
     var value = this.visitPostfixExpression((node && node.is$PostfixExpression()), true);
     value.checkFirstClass$1(node.span);
     return value;
   }
   return this.visitValue(node);
 }
 MethodGenerator.prototype.visitDietStatement = function(node) {
+  var $0;
   var parser = new lang_Parser(node.span.file, false, false, false, node.span.start);
-  this.visitStatementsInBlock(parser.block$0());
+  this.visitStatementsInBlock((($0 = parser.block$0()) && $0.is$lang_Statement()));
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var $0;
   var isFinal = false;
-  if ($notnull_bool(node.modifiers != null && $eq(node.modifiers.$index(0).kind, 97/*TokenKind.FINAL*/))) {
+  if ($notnull_bool(node.modifiers != null && $eq(node.modifiers.$index(0).get$kind(), 97/*TokenKind.FINAL*/))) {
     isFinal = true;
   }
   this.writer.write('var ');
   var type = this.method.resolveType(node.type, false);
   for (var i = 0;
    i < node.names.length; i++) {
     var thisType = type;
     if (i > 0) {
       this.writer.write(', ');
     }
     var name = node.names.$index(i).get$name();
     var value = this.visitValue((($0 = node.values.$index(i)) && $0.is$lang_Expression()));
     if ($notnull_bool(isFinal)) {
       if ($notnull_bool(value == null)) {
         world.error('no value specified for final variable', node.span);
       }
       else {
-        if ($notnull_bool(thisType.get$isVar())) thisType = value.type;
+        if ($notnull_bool(thisType.get$isVar())) thisType = value.get$type();
       }
     }
-    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), node.names.$index(i).get$span(), false);
+    var val = this._scope.create($assert_String(name), (thisType && thisType.is$lang_Type()), (($0 = node.names.$index(i).get$span()) && $0.is$SourceSpan()), false);
     if ($notnull_bool(value == null)) {
-      this.writer.write(('' + val.code + ''));
+      this.writer.write(('' + val.get$code() + ''));
     }
     else {
       value = value.convertTo$3(this, type, node.values.$index(i));
-      this.writer.write(('' + val.code + ' = ' + value.code + ''));
+      this.writer.write(('' + val.get$code() + ' = ' + value.get$code() + ''));
     }
   }
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype.visitFunctionDefinition = function(node) {
   var $0;
   var name = world.toJsIdentifier(node.name.name);
   var meth = this._makeLambdaMethod($assert_String(name), node);
-  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), this.method.get$definition().get$span(), false);
-  meth.generator.writeDefinition$2(this.writer);
+  var funcValue = this._scope.create($assert_String(name), (($0 = meth.get$functionType()) && $0.is$lang_Type()), (($0 = this.method.get$definition().get$span()) && $0.is$SourceSpan()), false);
+  meth.get$generator().writeDefinition$2(this.writer);
   return false;
 }
 MethodGenerator.prototype.visitReturnStatement = function(node) {
   if (node.value == null) {
     this.writer.writeln('return;');
   }
   else {
     if ($notnull_bool(this.method.get$isConstructor())) {
       world.error('return of value not allowed from constructor', node.span);
     }
     var value = this.visitTypedValue(node.value, this.method.get$returnType());
-    this.writer.writeln(('return ' + value.code + ';'));
+    this.writer.writeln(('return ' + value.get$code() + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitThrowStatement = function(node) {
   if (node.value != null) {
     var value = this.visitValue(node.value);
     value.invoke$4(this, 'toString', node, Arguments.get$EMPTY());
-    this.writer.writeln(('\$throw(' + value.code + ');'));
+    this.writer.writeln(('\$throw(' + value.get$code() + ');'));
     world.gen.corejs.useThrow = true;
   }
   else {
     var rethrow = this._scope.getRethrow();
     if ($notnull_bool(rethrow == null)) {
       world.error('rethrow outside of catch', node.span);
     }
     else {
-      this.writer.writeln(('throw ' + rethrow.code + ';'));
+      this.writer.writeln(('throw ' + rethrow.get$code() + ';'));
     }
   }
   return true;
 }
 MethodGenerator.prototype.visitAssertStatement = function(node) {
   var $0;
   var test = this.visitValue(node.test);
   if ($notnull_bool(options.enableAsserts)) {
     var err = world.corelib.types.$index('AssertError');
     world.gen.genMethod((($0 = err.getConstructor$1('')) && $0.is$Member()));
     world.gen.genMethod((($0 = err.get$members().$index('toString')) && $0.is$Member()));
     var span = node.test.span;
-    var line = span.file.getLine(span.start);
-    var column = span.file.getColumn($assert_num(line), span.start);
-    this.writer.writeln(('\$assert(' + test.code + ', "' + MethodGenerator._escapeString(span.get$text()) + '",') + (' "' + basename(span.file.filename) + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
+    var line = span.get$file().getLine$1(span.get$start());
+    var column = span.get$file().getColumn$2(line, span.get$start());
+    this.writer.writeln(('\$assert(' + test.get$code() + ', "' + MethodGenerator._escapeString($assert_String(span.get$text())) + '",') + (' "' + basename($assert_String(span.get$file().get$filename())) + '", ' + (line + 1) + ', ' + (column + 1) + ');'));
     world.gen.corejs.useAssert = true;
   }
   return false;
 }
 MethodGenerator.prototype.visitBreakStatement = function(node) {
   if (node.label == null) {
     this.writer.writeln('break;');
   }
   else {
     this.writer.writeln(('break ' + node.label.name + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitContinueStatement = function(node) {
   if (node.label == null) {
     this.writer.writeln('continue;');
   }
   else {
     this.writer.writeln(('continue ' + node.label.name + ';'));
   }
   return true;
 }
 MethodGenerator.prototype.visitIfStatement = function(node) {
   var test = this.visitBool(node.test);
-  this.writer.write(('if (' + test.code + ') '));
+  this.writer.write(('if (' + test.get$code() + ') '));
   var exit1 = node.trueBranch.visit(this);
   if (node.falseBranch != null) {
     this.writer.write('else ');
     if ($notnull_bool(node.falseBranch.visit(this) && exit1)) {
       return true;
     }
   }
   return false;
 }
 MethodGenerator.prototype.visitWhileStatement = function(node) {
   var test = this.visitBool(node.test);
-  this.writer.write(('while (' + test.code + ') '));
+  this.writer.write(('while (' + test.get$code() + ') '));
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype.visitDoStatement = function(node) {
   this.writer.write('do ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   var test = this.visitBool(node.test);
-  this.writer.writeln(('while (' + test.code + ')'));
+  this.writer.writeln(('while (' + test.get$code() + ')'));
   return false;
 }
 MethodGenerator.prototype.visitForStatement = function(node) {
   this._pushBlock(false);
   this.writer.write('for (');
   if (node.init != null) node.init.visit(this);
   else this.writer.write(';');
   if (node.test != null) {
     var test = this.visitBool(node.test);
-    this.writer.write((' ' + test.code + '; '));
+    this.writer.write((' ' + test.get$code() + '; '));
   }
   else {
     this.writer.write('; ');
   }
   var needsComma = false;
   var $list = node.step;
   for (var $i = 0;$i < $list.length; $i++) {
     var s = $list.$index($i);
     if ($notnull_bool(needsComma)) this.writer.write(', ');
     var sv = this.visitVoid((s && s.is$lang_Expression()));
-    this.writer.write($assert_String(sv.code));
+    this.writer.write($assert_String(sv.get$code()));
     needsComma = true;
   }
   this.writer.write(') ');
   this._pushBlock(true);
   node.body.visit(this);
   this._popBlock();
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
   var $0;
   var itemType = this.method.resolveType(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
   var item = this._scope.create($assert_String(itemName), (itemType && itemType.is$lang_Type()), node.item.name.span, false);
   var listVar = (list && list.is$Value());
-  if ($notnull_bool(list.needsTemp)) {
-    listVar = this._scope.create('\$list', (($0 = list.type) && $0.is$lang_Type()), null, false);
-    this.writer.writeln(('var ' + listVar.code + ' = ' + list.code + ';'));
+  if ($notnull_bool(list.get$needsTemp())) {
+    listVar = this._scope.create('\$list', (($0 = list.get$type()) && $0.is$lang_Type()), null, false);
+    this.writer.writeln(('var ' + listVar.code + ' = ' + list.get$code() + ';'));
   }
-  if ($notnull_bool(list.type.get$isList())) {
+  if ($notnull_bool(list.get$type().get$isList())) {
     var tmpi = this._scope.create('\$i', world.numType, null, false);
-    this.writer.enterBlock(('for (var ' + tmpi.code + ' = 0;') + ('' + tmpi.code + ' < ' + listVar.code + '.length; ' + tmpi.code + '++) {'));
+    this.writer.enterBlock(('for (var ' + tmpi.get$code() + ' = 0;') + ('' + tmpi.get$code() + ' < ' + listVar.code + '.length; ' + tmpi.get$code() + '++) {'));
     var value = listVar.invoke(this, '\$index', node.list, new Arguments(null, [tmpi]), false);
-    this.writer.writeln(('var ' + item.code + ' = ' + value.code + ';'));
+    this.writer.writeln(('var ' + item.get$code() + ' = ' + value.get$code() + ';'));
   }
   else {
     this._pushBlock(false);
     var iterator = list.invoke$4(this, 'iterator', node.list, Arguments.get$EMPTY());
-    var tmpi = this._scope.create('\$i', (($0 = iterator.type) && $0.is$lang_Type()), null, false);
+    var tmpi = this._scope.create('\$i', (($0 = iterator.get$type()) && $0.is$lang_Type()), null, false);
     var hasNext = tmpi.invoke$4(this, 'hasNext', node.list, Arguments.get$EMPTY());
     var next = tmpi.invoke$4(this, 'next', node.list, Arguments.get$EMPTY());
-    this.writer.enterBlock(('for (var ' + tmpi.code + ' = ' + iterator.code + '; ' + hasNext.code + '; ) {'));
-    this.writer.writeln(('var ' + item.code + ' = ' + next.code + ';'));
+    this.writer.enterBlock(('for (var ' + tmpi.get$code() + ' = ' + iterator.get$code() + '; ' + hasNext.get$code() + '; ) {'));
+    this.writer.writeln(('var ' + item.get$code() + ' = ' + next.get$code() + ';'));
   }
   this.visitStatementsInBlock(node.body);
   this.writer.exitBlock('}');
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._genToDartException = function(ex, node) {
   var types = const$397/*const [
         'NullPointerException', 'ObjectNotClosureException',
         'NoSuchMethodException', 'StackOverflowException']*/;
@@ skipping 10 matching lines @@
   var $0;
   this.writer.enterBlock('try {');
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
   if (node.catches.length == 1) {
     var catch_ = node.catches.$index(0);
     this._pushBlock(false);
     var ex = this._scope.declare((($0 = catch_.get$exception()) && $0.is$DeclaredIdentifier()));
     this._scope.rethrow = (ex && ex.is$Value());
-    this.writer.nextBlock(('} catch (' + ex.code + ') {'));
-    if (catch_.trace != null) {
-      var trace = this._scope.declare(catch_.trace);
-      this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
+    this.writer.nextBlock(('} catch (' + ex.get$code() + ') {'));
+    if ($notnull_bool($ne(catch_.get$trace(), null))) {
+      var trace = this._scope.declare((($0 = catch_.get$trace()) && $0.is$DeclaredIdentifier()));
+      this.writer.writeln(('var ' + trace.get$code() + ' = \$stackTraceOf(' + ex.get$code() + ');'));
       world.gen.corejs.useStackTraceOf = true;
     }
-    this._genToDartException($assert_String(ex.code), node);
-    if (!$notnull_bool(ex.type.get$isVar())) {
-      var test = ex.instanceOf$3$isTrue$forceCheck(this, ex.type, catch_.get$exception().get$span(), false, true);
-      this.writer.writeln(('if (' + test.code + ') throw ' + ex.code + ';'));
+    this._genToDartException($assert_String(ex.get$code()), node);
+    if (!$notnull_bool(ex.get$type().get$isVar())) {
+      var test = ex.instanceOf$3$isTrue$forceCheck(this, ex.get$type(), catch_.get$exception().get$span(), false, true);
+      this.writer.writeln(('if (' + test.get$code() + ') throw ' + ex.get$code() + ';'));
     }
-    this.visitStatementsInBlock((($0 = node.catches.$index(0).body) && $0.is$lang_Statement()));
+    this.visitStatementsInBlock((($0 = node.catches.$index(0).get$body()) && $0.is$lang_Statement()));
     this._popBlock();
   }
   else if (node.catches.length > 0) {
     this._pushBlock(false);
     var ex = this._scope.create('\$ex', world.varType, null, false);
     this._scope.rethrow = (ex && ex.is$Value());
-    this.writer.nextBlock(('} catch (' + ex.code + ') {'));
+    this.writer.nextBlock(('} catch (' + ex.get$code() + ') {'));
     var trace = null;
     if (node.catches.some((function (c) {
-      return c.trace != null;
+      return $ne(c.get$trace(), null);
     })
     )) {
       trace = this._scope.create('\$trace', world.varType, null, false);
-      this.writer.writeln(('var ' + trace.code + ' = \$stackTraceOf(' + ex.code + ');'));
+      this.writer.writeln(('var ' + trace.get$code() + ' = \$stackTraceOf(' + ex.get$code() + ');'));
       world.gen.corejs.useStackTraceOf = true;
     }
-    this._genToDartException($assert_String(ex.code), node);
+    this._genToDartException($assert_String(ex.get$code()), node);
     var needsRethrow = true;
     for (var i = 0;
      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())) {
-        var test = ex.instanceOf$3$isTrue$forceCheck(this, tmp.type, catch_.get$exception().get$span(), true, true);
+      if (!$notnull_bool(tmp.get$type().get$isVar())) {
+        var test = ex.instanceOf$3$isTrue$forceCheck(this, tmp.get$type(), catch_.get$exception().get$span(), true, true);
         if (i == 0) {
-          this.writer.enterBlock(('if (' + test.code + ') {'));
+          this.writer.enterBlock(('if (' + test.get$code() + ') {'));
         }
         else {
-          this.writer.nextBlock(('} else if (' + test.code + ') {'));
+          this.writer.nextBlock(('} else if (' + test.get$code() + ') {'));
         }
       }
       else if (i > 0) {
         this.writer.nextBlock('} else {');
       }
-      this.writer.writeln(('var ' + tmp.code + ' = ' + ex.code + ';'));
-      if (catch_.trace != null) {
-        var tmptrace = this._scope.declare(catch_.trace);
-        this.writer.writeln(('var ' + tmptrace.code + ' = ' + trace.code + ';'));
+      this.writer.writeln(('var ' + tmp.get$code() + ' = ' + ex.get$code() + ';'));
+      if ($notnull_bool($ne(catch_.get$trace(), null))) {
+        var tmptrace = this._scope.declare((($0 = catch_.get$trace()) && $0.is$DeclaredIdentifier()));
+        this.writer.writeln(('var ' + tmptrace.get$code() + ' = ' + trace.get$code() + ';'));
       }
-      this.visitStatementsInBlock((($0 = catch_.body) && $0.is$lang_Statement()));
+      this.visitStatementsInBlock((($0 = catch_.get$body()) && $0.is$lang_Statement()));
       this._popBlock();
-      if ($notnull_bool(tmp.type.get$isVar())) {
+      if ($notnull_bool(tmp.get$type().get$isVar())) {
         if (i + 1 < node.catches.length) {
           world.warning('Unreachable catch clause', (($0 = node.catches.$index(i + 1)) && $0.is$SourceSpan()));
         }
         if (i > 0) {
           this.writer.exitBlock('}');
         }
         needsRethrow = false;
         break;
       }
     }
     if ($notnull_bool(needsRethrow)) {
       this.writer.nextBlock('} else {');
-      this.writer.writeln(('throw ' + ex.code + ';'));
+      this.writer.writeln(('throw ' + ex.get$code() + ';'));
       this.writer.exitBlock('}');
     }
     this._popBlock();
   }
   if (node.finallyBlock != null) {
     this.writer.nextBlock('} finally {');
     this._pushBlock(false);
     this.visitStatementsInBlock(node.finallyBlock);
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype.visitSwitchStatement = function(node) {
+  var $0;
   var test = this.visitValue(node.test);
-  this.writer.enterBlock(('switch (' + test.code + ') {'));
+  this.writer.enterBlock(('switch (' + test.get$code() + ') {'));
   var $list = node.cases;
   for (var $i = 0;$i < $list.length; $i++) {
     var case_ = $list.$index($i);
-    if (case_.label != null) {
-      world.error('unimplemented: labeled case statement', case_.get$span());
+    if ($notnull_bool($ne(case_.get$label(), null))) {
+      world.error('unimplemented: labeled case statement', (($0 = case_.get$span()) && $0.is$SourceSpan()));
     }
     this._pushBlock(false);
     for (var i = 0;
-     i < case_.cases.length; i++) {
-      var expr = case_.cases.$index(i);
+     i < $assert_num(case_.get$cases().length); i++) {
+      var expr = case_.get$cases().$index(i);
       if ($notnull_bool(expr == null)) {
-        if (i < case_.cases.length - 1) {
-          world.error('default clause must be the last case', case_.get$span());
+        if (i < case_.get$cases().length - 1) {
+          world.error('default clause must be the last case', (($0 = case_.get$span()) && $0.is$SourceSpan()));
         }
         this.writer.writeln('default:');
       }
       else {
         var value = this.visitValue((expr && expr.is$lang_Expression()));
-        this.writer.writeln(('case ' + value.code + ':'));
+        this.writer.writeln(('case ' + value.get$code() + ':'));
       }
     }
     this.writer.enterBlock('');
-    var caseExits = this._visitAllStatements(case_.statements, false);
+    var caseExits = this._visitAllStatements(case_.get$statements(), false);
     if ($notnull_bool($ne(case_, node.cases.$index(node.cases.length - 1)) && !$notnull_bool(caseExits))) {
-      var span = case_.statements.$index(case_.statements.length - 1).get$span();
+      var span = case_.get$statements().$index(case_.get$statements().length - 1).get$span();
       this.writer.writeln('\$throw(new FallThroughError());');
       world.gen.corejs.useThrow = true;
     }
     this.writer.exitBlock('');
     this._popBlock();
   }
   this.writer.exitBlock('}');
   return false;
 }
 MethodGenerator.prototype._visitAllStatements = function(statementList, exits) {
+  var $0;
   for (var i = 0;
-   i < statementList.length; i++) {
+   i < $assert_num(statementList.length); i++) {
     var stmt = statementList.$index(i);
     exits = stmt.visit$1(this);
     if ($notnull_bool($ne(stmt, statementList.$index(statementList.length - 1)) && exits)) {
-      world.warning('unreachable code', statementList.$index(i + 1).get$span());
+      world.warning('unreachable code', (($0 = statementList.$index(i + 1).get$span()) && $0.is$SourceSpan()));
     }
   }
   return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitBlockStatement = function(node) {
   this._pushBlock(false);
   this.writer.enterBlock('{');
   var exits = this._visitAllStatements(node.body, false);
   this.writer.exitBlock('}');
   this._popBlock();
   return $assert_bool(exits);
 }
 MethodGenerator.prototype.visitLabeledStatement = function(node) {
   this.writer.writeln(('' + node.name.name + ':'));
   node.body.visit(this);
   return false;
 }
 MethodGenerator.prototype.visitExpressionStatement = function(node) {
   if ((node.body instanceof VarExpression) || (node.body instanceof ThisExpression)) {
     world.warning('variable used as statement', node.span);
   }
   var value = this.visitVoid(node.body);
-  this.writer.writeln(('' + value.code + ';'));
+  this.writer.writeln(('' + value.get$code() + ';'));
   return false;
 }
 MethodGenerator.prototype.visitEmptyStatement = function(node) {
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype._checkNonStatic = function(node) {
   if ($notnull_bool(this.get$isStatic())) {
     world.warning('not allowed in static method', node.span);
   }
 }
 MethodGenerator.prototype._makeSuperValue = function(node) {
   var parentType = this.method.declaringType.get$parent();
   this._checkNonStatic(node);
   if ($notnull_bool(parentType == null)) {
     world.error('no super class', node.span);
   }
   var ret = new Value(parentType, 'this', node.span, false);
-  ret.isSuper = true;
+  ret.set$isSuper(true);
   return ret;
 }
 MethodGenerator.prototype._getOutermostMethod = function() {
   var result = this;
-  while (result.enclosingMethod != null) {
-    result = result.enclosingMethod;
+  while ($notnull_bool($ne(result.get$enclosingMethod(), null))) {
+    result = result.get$enclosingMethod();
   }
   return result;
 }
 MethodGenerator.prototype._makeThisCode = function() {
   if (this.enclosingMethod != null) {
-    this._getOutermostMethod().needsThis = true;
+    this._getOutermostMethod().set$needsThis(true);
     return '\$this';
   }
   else {
     return 'this';
   }
 }
 MethodGenerator.prototype._makeThisValue = function(node) {
   if (this.enclosingMethod != null) {
     var outermostMethod = this._getOutermostMethod();
     outermostMethod._checkNonStatic(node);
-    outermostMethod.needsThis = true;
-    return new Value(outermostMethod.method.declaringType, '\$this', node != null ? node.span : null, false);
+    outermostMethod.set$needsThis(true);
+    return new Value(outermostMethod.method.get$declaringType(), '\$this', node != null ? node.span : null, false);
   }
   else {
     this._checkNonStatic(node);
     return new Value(this.method.declaringType, 'this', node != null ? node.span : null, false);
   }
 }
 MethodGenerator.prototype.visitLambdaExpression = function(node) {
   var name = '';
   if (node.func.name != null) {
     name = world.toJsIdentifier(node.func.name.name);
   }
   var meth = this._makeLambdaMethod($assert_String(name), node.func);
   var w = new CodeWriter();
-  meth.generator.writeDefinition$2(w, node);
+  meth.get$generator().writeDefinition$2(w, node);
   return new Value(meth.get$functionType(), w.get$text(), node.span, true);
 }
 MethodGenerator.prototype.visitCallExpression = function(node) {
   var $0;
   var target;
   var position = node.target;
   var name = '\$call';
   if ((node.target instanceof DotExpression)) {
     var dot = (($0 = node.target) && $0.is$DotExpression());
     target = dot.self.visit(this);
@@ skipping 19 matching lines @@
   var target = this.visitValue(node.target);
   var index = this.visitValue(node.index);
   return target.invoke$4(this, '\$index', node, new Arguments(null, [index]));
 }
 MethodGenerator.prototype.visitBinaryExpression = function(node) {
   var $0;
   var kind = node.op.kind;
   if (kind == 35/*TokenKind.AND*/ || kind == 34/*TokenKind.OR*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
-    var code = ('' + x.code + ' ' + node.op + ' ' + y.code + '');
+    var code = ('' + x.get$code() + ' ' + node.op + ' ' + y.get$code() + '');
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
       var value = (kind == 35/*TokenKind.AND*/) ? $notnull_bool(x.get$actualValue() && y.get$actualValue()) : $notnull_bool(x.get$actualValue() || y.get$actualValue());
-      return EvaluatedValue.EvaluatedValue$factory((($0 = x.type) && $0.is$lang_Type()), value, ('' + value + ''), node.span);
+      return EvaluatedValue.EvaluatedValue$factory((($0 = x.get$type()) && $0.is$lang_Type()), value, ('' + value + ''), node.span);
     }
-    var ret = new Value(lang_Type.union((($0 = x.type) && $0.is$lang_Type()), (($0 = y.type) && $0.is$lang_Type())), code, node.span, true);
+    var ret = new Value(lang_Type.union((($0 = x.get$type()) && $0.is$lang_Type()), (($0 = y.get$type()) && $0.is$lang_Type())), code, node.span, true);
     return ret.convertTo$3(this, world.nonNullBool, node);
   }
   else if (kind == 50/*TokenKind.EQ_STRICT*/ || kind == 51/*TokenKind.NE_STRICT*/) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     if ($notnull_bool(x.get$isConst() && y.get$isConst())) {
       var value = kind == 50/*TokenKind.EQ_STRICT*/ ? $eq(x.get$actualValue(), y.get$actualValue()) : $ne(x.get$actualValue(), y.get$actualValue());
       return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, value, ("" + value + ""), node.span);
     }
-    if ($notnull_bool($eq(x.code, 'null') || $eq(y.code, 'null'))) {
+    if ($notnull_bool($eq(x.get$code(), 'null') || $eq(y.get$code(), 'null'))) {
       var op = node.op.toString().substring(0, 2);
-      return new Value(world.nonNullBool, ('' + x.code + ' ' + op + ' ' + y.code + ''), node.span, true);
+      return new Value(world.nonNullBool, ('' + x.get$code() + ' ' + op + ' ' + y.get$code() + ''), node.span, true);
     }
     else {
-      return new Value(world.nonNullBool, ('' + x.code + ' ' + node.op + ' ' + y.code + ''), node.span, true);
+      return new Value(world.nonNullBool, ('' + x.get$code() + ' ' + node.op + ' ' + y.get$code() + ''), node.span, true);
     }
   }
   var assignKind = TokenKind.kindFromAssign(node.op.kind);
   if (assignKind == -1) {
     var x = this.visitValue(node.x);
     var y = this.visitValue(node.y);
     var name = TokenKind.binaryMethodName(node.op.kind);
     if (node.op.kind == 49/*TokenKind.NE*/) {
       name = '\$ne';
     }
@@ skipping 61 matching lines @@
           right = captureOriginal((right && right.is$Value()));
           y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
         }
         return members._set$4(this, position, x, y);
       }
       else {
         x = members._get$3(this, position, x);
       }
     }
   }
-  y = y.convertTo$3(this, x.type, yn);
+  y = y.convertTo$3(this, x.get$type(), yn);
   if (kind == 0) {
     x = captureOriginal((x && x.is$Value()));
-    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
+    return new Value(y.get$type(), ('' + x.get$code() + ' = ' + y.get$code() + ''), position.span, true);
   }
-  else if ($notnull_bool(x.type.get$isNum() && y.type.get$isNum()) && (kind != 46/*TokenKind.TRUNCDIV*/)) {
+  else if ($notnull_bool(x.get$type().get$isNum() && y.get$type().get$isNum()) && (kind != 46/*TokenKind.TRUNCDIV*/)) {
     x = captureOriginal((x && x.is$Value()));
     var op = TokenKind.kindToString(kind);
-    return new Value(y.type, ('' + x.code + ' ' + op + '= ' + y.code + ''), position.span, true);
+    return new Value(y.get$type(), ('' + x.get$code() + ' ' + op + '= ' + y.get$code() + ''), position.span, true);
   }
   else {
     var right = x;
     right = captureOriginal((right && right.is$Value()));
     y = right.invoke$4(this, TokenKind.binaryMethodName(kind), position, new Arguments(null, [y]));
-    return new Value(y.type, ('' + x.code + ' = ' + y.code + ''), position.span, true);
+    return new Value(y.get$type(), ('' + x.get$code() + ' = ' + y.get$code() + ''), position.span, true);
   }
 }
 MethodGenerator.prototype._visitIndexAssign = function(kind, xn, yn, position, captureOriginal) {
   var target = this.visitValue(xn.target);
   var index = this.visitValue(xn.index);
   var y = this.visitValue(yn);
   var tmptarget = target;
   var tmpindex = index;
   if (kind != 0) {
     tmptarget = this.getTemp((target && target.is$Value()));
@@ skipping 22 matching lines @@
   if ($notnull_bool($ne(tmptarget, target))) this.freeTemp((tmptarget && tmptarget.is$Value()));
   return ret;
 }
 MethodGenerator.prototype.visitUnaryExpression = function(node) {
   var $0;
   var value = this.visitValue(node.self);
   switch (node.op.kind) {
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
-      if ($notnull_bool(value.type.get$isNum())) {
-        return new Value(value.type, ('' + node.op + '' + value.code + ''), node.span, true);
+      if ($notnull_bool(value.get$type().get$isNum())) {
+        return new Value(value.get$type(), ('' + node.op + '' + value.get$code() + ''), node.span, true);
       }
       else {
         var kind = (16/*TokenKind.INCR*/ == node.op.kind ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/);
         var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
         return this._visitAssign($assert_num(kind), node.self, (operand && operand.is$lang_Expression()), node, to$call$1(null));
       }
 
     case 19/*TokenKind.NOT*/:
 
-      if ($notnull_bool(value.type.get$isBool() && value.get$isConst())) {
+      if ($notnull_bool(value.get$type().get$isBool() && value.get$isConst())) {
         var newVal = !$notnull_bool(value.get$actualValue());
-        return EvaluatedValue.EvaluatedValue$factory((($0 = value.type) && $0.is$lang_Type()), newVal, ('' + newVal + ''), node.span);
+        return EvaluatedValue.EvaluatedValue$factory((($0 = value.get$type()) && $0.is$lang_Type()), newVal, ('' + newVal + ''), node.span);
       }
       else {
         var newVal = value.convertTo$3(this, world.nonNullBool, node);
-        return new Value(newVal.type, ('!' + newVal.code + ''), node.span, true);
+        return new Value(newVal.get$type(), ('!' + newVal.get$code() + ''), node.span, true);
       }
 
     case 42/*TokenKind.ADD*/:
 
       return value.convertTo$3(this, world.numType, node);
 
     case 43/*TokenKind.SUB*/:
     case 18/*TokenKind.BIT_NOT*/:
 
       if (node.op.kind == 18/*TokenKind.BIT_NOT*/) {
         return value.invoke$4(this, '\$bit_not', node, Arguments.get$EMPTY());
       }
       else if (node.op.kind == 43/*TokenKind.SUB*/) {
         return value.invoke$4(this, '\$negate', node, Arguments.get$EMPTY());
       }
       else {
         world.internalError(('unimplemented: unary ' + node.op + ''), node.span);
       }
       $throw(new FallThroughError());
 
     default:
 
       world.internalError(('unimplemented: ' + node.op + ''), node.span);
 
   }
 }
 MethodGenerator.prototype.visitPostfixExpression = function(node, isVoid) {
   var $this = this; // closure support
   var value = this.visitValue(node.body);
-  if ($notnull_bool(value.type.get$isNum())) {
-    return new Value(value.type, ('' + value.code + '' + node.op + ''), node.span, true);
+  if ($notnull_bool(value.get$type().get$isNum())) {
+    return new Value(value.get$type(), ('' + value.get$code() + '' + node.op + ''), node.span, true);
   }
   var kind = (16/*TokenKind.INCR*/ == node.op.kind) ? 42/*TokenKind.ADD*/ : 43/*TokenKind.SUB*/;
   var operand = new LiteralExpression(1, new TypeReference(node.span, world.numType), '1', node.span);
   var tmpleft = null, left = null;
   var ret = this._visitAssign($assert_num(kind), node.body, (operand && operand.is$lang_Expression()), node, (function (l) {
     if ($notnull_bool(isVoid)) {
       return l;
     }
     else {
       left = l;
       tmpleft = $this.forceTemp((l && l.is$Value()));
       return $this.assignTemp((tmpleft && tmpleft.is$Value()), (left && left.is$Value()));
     }
   })
   );
   if ($notnull_bool($ne(tmpleft, null))) {
-    ret = new Value(ret.type, ("(" + ret.code + ", " + tmpleft.code + ")"), node.span, true);
+    ret = new Value(ret.get$type(), ("(" + ret.get$code() + ", " + tmpleft.get$code() + ")"), node.span, true);
   }
   if ($notnull_bool($ne(tmpleft, left))) {
     this.freeTemp((tmpleft && tmpleft.is$Value()));
   }
   return ret;
 }
 MethodGenerator.prototype.visitNewExpression = function(node) {
   var $0;
   var typeRef = node.type;
   var constructorName = '';
   if (node.name != null) {
     constructorName = node.name.name;
   }
-  if ($notnull_bool($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference)) && typeRef.names != null) {
-    var names = ListFactory.ListFactory$from$factory(typeRef.names);
+  if ($notnull_bool($notnull_bool($eq(constructorName, '') && !(typeRef instanceof GenericTypeReference)) && $ne(typeRef.get$names(), null))) {
+    var names = ListFactory.ListFactory$from$factory((($0 = typeRef.get$names()) && $0.is$Iterable()));
     constructorName = names.removeLast$0().get$name();
-    if (names.length == 0) names = null;
-    typeRef = new NameTypeReference(typeRef.isFinal, typeRef.get$name(), names, typeRef.get$span());
+    if ($notnull_bool($eq(names.length, 0))) names = null;
+    typeRef = new NameTypeReference(typeRef.get$isFinal(), typeRef.get$name(), names, (($0 = typeRef.get$span()) && $0.is$SourceSpan()));
   }
   var type = this.method.resolveType(typeRef, true);
   if ($notnull_bool(type.get$isTop())) {
-    type = type.get$library().findTypeByName($assert_String(constructorName));
+    type = type.get$library().findTypeByName$1(constructorName);
     constructorName = '';
   }
   var m = type.getConstructor$1(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())) {
       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())) {
-        world.error('const constructor expects const arguments', arg.get$span());
+        world.error('const constructor expects const arguments', (($0 = arg.get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   return m.invoke$4(this, node, null, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
+  var $0;
   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$1(arg);
     if ($notnull_bool(node.isConst)) {
       if (!$notnull_bool(arg.get$isConst())) {
-        world.error('const list can only contain const values', item.get$span());
-        argsCode.add$1(arg.code);
+        world.error('const list can only contain const values', (($0 = item.get$span()) && $0.is$SourceSpan()));
+        argsCode.add$1(arg.get$code());
       }
       else {
         argsCode.add$1(arg.get$canonicalCode());
       }
     }
     else {
-      argsCode.add$1(arg.code);
+      argsCode.add$1(arg.get$code());
     }
   }
   world.get$coreimpl().types.$index('ListFactory').markUsed$0();
   var code = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var value = new Value(world.listType, code, node.span, true);
   if ($notnull_bool(node.isConst)) {
     var immutableList = world.get$coreimpl().types.$index('ImmutableList');
     var immutableListCtor = immutableList.getConstructor$1('from');
     var result = immutableListCtor.invoke$4(this, node, null, new Arguments(null, [value]));
-    value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), $assert_String(result.code), node.span), (argValues && argValues.is$List$Value()));
+    value = world.gen.globalForConst(ConstListValue.ConstListValue$factory((immutableList && immutableList.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), ('const ' + code + ''), $assert_String(result.get$code()), node.span), (argValues && argValues.is$List$Value()));
   }
   return value;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   var $0;
   var mapImplType = world.gen.useMapFactory();
   var argValues = [];
   var argsCode = [];
   for (var i = 0;
    i < node.items.length; i += 2) {
     var key = this.visitTypedValue((($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$1(key);
     argValues.add$1(value);
     if ($notnull_bool(node.isConst)) {
       if (!$notnull_bool(key.get$isConst()) || !$notnull_bool(value.get$isConst())) {
-        world.error('const map can only contain const values', valueItem.get$span());
-        argsCode.add$1(key.code);
-        argsCode.add$1(value.code);
+        world.error('const map can only contain const values', (($0 = valueItem.get$span()) && $0.is$SourceSpan()));
+        argsCode.add$1(key.get$code());
+        argsCode.add$1(value.get$code());
       }
       else {
         argsCode.add$1(key.get$canonicalCode());
         argsCode.add$1(value.get$canonicalCode());
       }
     }
     else {
-      argsCode.add$1(key.code);
-      argsCode.add$1(value.code);
+      argsCode.add$1(key.get$code());
+      argsCode.add$1(value.get$code());
     }
   }
   var argList = ('[' + Strings.join((argsCode && argsCode.is$List$String()), ", ") + ']');
   var code = ('\$map(' + argList + ')');
   if ($notnull_bool(node.isConst)) {
     var immutableMap = world.get$coreimpl().types.$index('ImmutableMap');
     var immutableMapCtor = immutableMap.getConstructor$1('');
     var argsValue = new Value(world.listType, argList, node.span, true);
     var result = immutableMapCtor.invoke$4(this, node, null, new Arguments(null, [argsValue]));
-    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, $assert_String(result.code), node.span);
+    var value = ConstMapValue.ConstMapValue$factory((immutableMap && immutableMap.is$lang_Type()), (argValues && argValues.is$List$EvaluatedValue()), code, $assert_String(result.get$code()), node.span);
     return world.gen.globalForConst(value, (argValues && argValues.is$List$Value()));
   }
   return new Value(mapImplType, code, node.span, true);
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var $0;
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
-  var code = ('' + test.code + ' ? ' + trueBranch.code + ' : ' + falseBranch.code + '');
-  return new Value(lang_Type.union((($0 = trueBranch.type) && $0.is$lang_Type()), (($0 = falseBranch.type) && $0.is$lang_Type())), code, node.span, true);
+  var code = ('' + test.get$code() + ' ? ' + trueBranch.get$code() + ' : ' + falseBranch.get$code() + '');
+  return new Value(lang_Type.union((($0 = trueBranch.get$type()) && $0.is$lang_Type()), (($0 = falseBranch.get$type()) && $0.is$lang_Type())), code, node.span, true);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
   var type = this.method.resolveType(node.type, false);
   return value.instanceOf$4(this, type, node.span, node.isTrue);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var $0;
   var body = this.visitValue(node.body);
   if ($notnull_bool(body.get$isConst())) {
-    return EvaluatedValue.EvaluatedValue$factory((($0 = body.type) && $0.is$lang_Type()), body.get$actualValue(), ('(' + body.get$canonicalCode() + ')'), node.span);
+    return EvaluatedValue.EvaluatedValue$factory((($0 = body.get$type()) && $0.is$lang_Type()), body.get$actualValue(), ('(' + body.get$canonicalCode() + ')'), node.span);
   }
-  return new Value(body.type, ('(' + body.code + ')'), node.span, true);
+  return new Value(body.get$type(), ('(' + body.get$code() + ')'), node.span, true);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_$3(this, node.name.name, node.name);
 }
 MethodGenerator.prototype.visitVarExpression = function(node) {
   var name = node.name.name;
   var ret = this._scope.lookup(name);
   if ($notnull_bool($ne(ret, null))) return ret;
   return this._makeThisOrType(node.span).get_$3(this, name, node);
@@ skipping 18 matching lines @@
   var $0;
   var type = node.type.type;
   $assert($ne(type, null), "type != null", "gen.dart", 2083, 12);
   if (!!(($0 = node.value) && $0.is$List)) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator$0(); $i.hasNext$0(); ) {
       var item = $i.next$0();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
-      var code = val.code;
+      var code = val.get$code();
       if ((item instanceof BinaryExpression) || (item instanceof ConditionalExpression)) {
         code = ('(' + code + ')');
       }
       items.add$1(code);
     }
     return new Value(type, ('(' + Strings.join((items && items.is$List$String()), " + ") + ')'), node.span, true);
   }
   var text = node.text;
   if ($notnull_bool(type.get$isString())) {
     if ($notnull_bool(text.startsWith$1('@'))) {
@@ skipping 33 matching lines @@
     values.add$1(new Value(world.varType, ('\$' + i + ''), null, false));
   }
   return new Arguments(null, values);
 }
 Arguments.get$EMPTY = function() {
   if (Arguments._empty == null) {
     Arguments._empty = new Arguments(null, []);
   }
   return Arguments._empty;
 }
+Arguments.prototype.get$values = function() { return this.values; };
+Arguments.prototype.set$values = function(value) { return this.values = value; };
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
 Arguments.prototype.get$hasNames = function() {
   return this.get$bareCount() < this.get$length();
 }
 Arguments.prototype.get$length = function() {
   return this.values.length;
 }
 Object.defineProperty(Arguments.prototype, "length", {
   get: Arguments.prototype.get$length
 });
 Arguments.prototype.getName = function(i) {
-  return this.nodes.$index(i).label.name;
+  return $assert_String(this.nodes.$index(i).get$label().get$name());
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    i < this.get$length(); i++) {
     if (this.getName(i) == name) {
       return i;
     }
   }
   return -1;
 }
 Arguments.prototype.getValue = function(name) {
   var $0;
   var i = this.getIndexOfName(name);
   return (($0 = i >= 0 ? this.values.$index(i) : null) && $0.is$Value());
 }
 Arguments.prototype.get$bareCount = function() {
   if (this._bareCount == null) {
     this._bareCount = this.get$length();
     if (this.nodes != null) {
       for (var i = 0;
        i < this.nodes.length; i++) {
-        if (this.nodes.$index(i).label != null) {
+        if ($notnull_bool($ne(this.nodes.$index(i).get$label(), null))) {
           this._bareCount = i;
           break;
         }
       }
     }
   }
   return this._bareCount;
 }
 Arguments.prototype.getCode = function() {
   var argsCode = [];
   for (var i = 0;
    i < this.get$length(); i++) {
-    argsCode.add$1(this.values.$index(i).code);
+    argsCode.add$1(this.values.$index(i).get$code());
   }
   Arguments.removeTrailingNulls((argsCode && argsCode.is$List$Value()));
   return Strings.join((argsCode && argsCode.is$List$String()), ", ");
 }
 Arguments.removeTrailingNulls = function(argsCode) {
   while ($notnull_bool(argsCode.length > 0 && $eq(argsCode.last(), 'null'))) {
     argsCode.removeLast();
   }
 }
 Arguments.prototype.getNames = function() {
@@ skipping 17 matching lines @@
     result.add$1(new Value(world.varType, name, null, false));
   }
   return new Arguments(this.nodes, result);
 }
 // ********** Code for LibraryImport **************
 function LibraryImport(library, prefix) {
   this.library = library;
   this.prefix = prefix;
   // Initializers done
 }
+LibraryImport.prototype.get$prefix = function() { return this.prefix; };
+LibraryImport.prototype.set$prefix = function(value) { return this.prefix = value; };
 LibraryImport.prototype.get$library = function() { return this.library; };
 LibraryImport.prototype.set$library = function(value) { return this.library = value; };
 // ********** Code for Library **************
 function Library(baseSource) {
   this.isWritten = false
   this.baseSource = baseSource;
   // Initializers done
   this.sourceDir = dirname(this.baseSource.filename);
   this.topType = new DefinedType(null, this, null, true);
   this.types = $map(['', this.topType]);
   this.imports = [];
   this.natives = [];
   this.sources = [];
   this._privateMembers = $map([]);
 }
 Library.prototype.is$Library = function(){return this;};
+Library.prototype.get$baseSource = function() { return this.baseSource; };
+Library.prototype.get$types = function() { return this.types; };
+Library.prototype.set$types = function(value) { return this.types = value; };
 Library.prototype.get$name = function() { return this.name; };
 Library.prototype.set$name = function(value) { return this.name = value; };
+Library.prototype.get$topType = function() { return this.topType; };
+Library.prototype.set$topType = function(value) { return this.topType = value; };
 Library.prototype.get$isCore = function() {
   return $eq(this, world.corelib);
 }
 Library.prototype.get$isCoreImpl = function() {
   return $eq(this, world.get$coreimpl());
 }
 Library.prototype.get$jsname = function() {
   if (this._jsname == null) {
     this._jsname = this.name.replaceAll('.', '_').replaceAll(':', '_').replaceAll(' ', '_');
   }
@@ skipping 87 matching lines @@
       return null;
     }
     if (!$notnull_bool(result.get$isTop())) {
       return null;
     }
     return result.get$library().findTypeByName($assert_String(type.names.$index(0).get$name()));
   }
   return result;
 }
 Library.prototype.findTypeByName = function(name) {
+  var $0;
   var ret = this.types.$index(name);
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
     var newRet = null;
-    if (imported.prefix == null) {
-      newRet = imported.get$library().types.$index(name);
+    if ($notnull_bool(imported.get$prefix() == null)) {
+      newRet = imported.get$library().get$types().$index(name);
     }
-    else if (imported.prefix == name) {
-      newRet = imported.get$library().topType;
+    else if ($notnull_bool($eq(imported.get$prefix(), name))) {
+      newRet = imported.get$library().get$topType();
     }
     if ($notnull_bool($ne(newRet, null))) {
       if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-        world.error(('conflicting types for "' + name + '"'), ret.get$span(), newRet.get$span());
+        world.error(('conflicting types for "' + name + '"'), (($0 = ret.get$span()) && $0.is$SourceSpan()), (($0 = newRet.get$span()) && $0.is$SourceSpan()));
       }
       else {
         ret = newRet;
       }
     }
   }
   return (ret && ret.is$lang_Type());
 }
 Library.prototype.lookup = function(name, span) {
+  var $0;
   var retType = this.findTypeByName(name);
   var ret = null;
   if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name);
   if ($notnull_bool($ne(newRet, null))) {
     if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-      world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
+      world.error(('conflicting members for "' + name + '"'), span, (($0 = ret.get$span()) && $0.is$SourceSpan()), (($0 = newRet.get$span()) && $0.is$SourceSpan()));
     }
     else {
       ret = newRet;
     }
   }
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
-    if (imported.prefix == null) {
-      newRet = imported.get$library().topType.getMember(name);
+    if ($notnull_bool(imported.get$prefix() == null)) {
+      newRet = imported.get$library().get$topType().getMember$1(name);
       if ($notnull_bool($ne(newRet, null))) {
         if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-          world.error(('conflicting members for "' + name + '"'), span, ret.get$span(), newRet.get$span());
+          world.error(('conflicting members for "' + name + '"'), span, (($0 = ret.get$span()) && $0.is$SourceSpan()), (($0 = newRet.get$span()) && $0.is$SourceSpan()));
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   return (ret && ret.is$Member());
 }
 Library.prototype.resolve = function() {
@@ skipping 14 matching lines @@
     type.resolve$0();
   }
 }
 Library.prototype.visitSources = function() {
   var visitor = new _LibraryVisitor(this);
   visitor.addSource$1(this.baseSource);
 }
 Library.prototype.toString = function() {
   return this.baseSource.filename;
 }
+Library.prototype.findTypeByName$1 = function($0) {
+  return this.findTypeByName($assert_String($0));
+};
 Library.prototype.resolve$0 = function() {
   return this.resolve();
 };
 Library.prototype.toString$0 = function() {
   return this.toString();
 };
 Library.prototype.visitSources$0 = function() {
   return this.visitSources();
 };
 // ********** Code for _LibraryVisitor **************
@@ skipping 11 matching lines @@
 _LibraryVisitor.prototype.get$library = function() { return this.library; };
 _LibraryVisitor.prototype.get$isTop = function() { return this.isTop; };
 _LibraryVisitor.prototype.set$isTop = function(value) { return this.isTop = value; };
 _LibraryVisitor.prototype.addSourceFromName = function(name, span) {
   var filename = this.library.makeFullPath(name);
   if ($notnull_bool($eq(filename, this.library.baseSource.filename))) {
     world.error('library can not source itself', span);
     return;
   }
   else if (this.sources.some((function (s) {
-    return s.filename == filename;
+    return $eq(s.get$filename(), filename);
   })
   )) {
     world.error(('file "' + filename + '" has already been sourced'), span);
     return;
   }
   var source = world.readFile(this.library.makeFullPath(name));
   this.sources.add(source);
 }
 _LibraryVisitor.prototype.addSource = function(source) {
   var $this = this; // closure support
   if (this.library.sources.some((function (s) {
-    return s.filename == source.filename;
+    return $eq(s.get$filename(), source.filename);
   })
   )) {
     world.error(('duplicate source file "' + source.filename + '"'));
     return;
   }
   this.library.sources.add(source);
   var parser = new lang_Parser(source, options.dietParse, false, false, 0);
   var unit = parser.compilationUnit();
   unit.forEach((function (def) {
     return def.visit$1($this);
@@ skipping 42 matching lines @@
       }
       else if ($notnull_bool($ne(prefix, null) && prefix.indexOf$2('.', 0) >= 0)) {
         world.error('library prefix canot contain "."', node.span);
       }
       else if ($notnull_bool(this.seenSource || this.seenResource)) {
         world.error('#imports must come before any #source or #resource', node.span);
       }
       if ($notnull_bool($eq(prefix, ''))) prefix = null;
       var filename = this.library.makeFullPath($assert_String(name));
       if (this.library.imports.some((function (li) {
-        return $eq(li.get$library().baseSource, filename);
+        return $eq(li.get$library().get$baseSource(), filename);
       })
       )) {
         world.error(('duplicate import of "' + name + '"'), node.span);
         return;
       }
       var newLib = this.library.addImport($assert_String(filename), $assert_String(prefix));
       break;
 
     case "source":
 
@@ skipping 27 matching lines @@
   if (node.arguments.length != 1) {
     world.error(('expected exactly one argument but found ' + node.arguments.length + ''), node.span);
   }
   return this.getFirstStringArg(node);
 }
 _LibraryVisitor.prototype.getFirstStringArg = function(node) {
   if (node.arguments.length < 1) {
     world.error(('expected at least one argument but found ' + node.arguments.length + ''), node.span);
   }
   var arg = node.arguments.$index(0);
-  if (arg.label != null) {
+  if ($notnull_bool($ne(arg.get$label(), null))) {
     world.error('label not allowed for directive', node.span);
   }
   return this._parseStringArgument((arg && arg.is$ArgumentNode()));
 }
 _LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var args = node.arguments.filter((function (a) {
-    return a.label != null && a.label.name == argName;
+    return $notnull_bool($ne(a.get$label(), null) && $eq(a.get$label().get$name(), argName));
   })
   );
-  if (args.length == 0) {
+  if ($notnull_bool($eq(args.length, 0))) {
     return null;
   }
   if (args.length > 1) {
     world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
   }
   for (var $i = args.iterator$0(); $i.hasNext$0(); ) {
     var arg = $i.next$0();
     return this._parseStringArgument((arg && arg.is$ArgumentNode()));
   }
 }
 _LibraryVisitor.prototype._parseStringArgument = function(arg) {
+  var $0;
   var expr = arg.value;
-  if (!(expr instanceof LiteralExpression) || !$notnull_bool(expr.type.type.get$isString())) {
-    world.error('expected string', expr.get$span());
+  if (!(expr instanceof LiteralExpression) || !$notnull_bool(expr.get$type().get$type().get$isString())) {
+    world.error('expected string', (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
   return parseStringLiteral($assert_String(expr.get$value()));
 }
 _LibraryVisitor.prototype.visitTypeDefinition = function(node) {
   var oldType = this.currentType;
   this.currentType = this.library.addType(node.name.name, node, node.isClass);
   var $list = node.body;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
     member.visit$1(this);
@@ skipping 17 matching lines @@
 function Parameter(definition) {
   this.isInitializer = false
   this.definition = definition;
   // Initializers done
 }
 Parameter.prototype.is$Parameter = function(){return this;};
 Parameter.prototype.get$definition = function() { return this.definition; };
 Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 Parameter.prototype.get$name = function() { return this.name; };
 Parameter.prototype.set$name = function(value) { return this.name = value; };
+Parameter.prototype.get$type = function() { return this.type; };
+Parameter.prototype.set$type = function(value) { return this.type = value; };
+Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
+Parameter.prototype.set$isInitializer = function(value) { return this.isInitializer = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function(method, inType) {
   this.name = this.definition.name.name;
   if (this.name.startsWith('this.')) {
     this.name = this.name.substring(5);
     this.isInitializer = true;
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(method.get$isStatic() && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.span);
   }
   if (this.definition.value != null) {
     if ((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start) {
       return;
     }
     if ($notnull_bool(method.get$isAbstract())) {
       world.error('default value not allowed on abstract methods', this.definition.span);
     }
-    else if ($notnull_bool(method.name == '\$call' && method.get$definition().body == null)) {
+    else if ($notnull_bool(method.name == '\$call' && method.get$definition().get$body() == null)) {
       world.error('default value not allowed on function type', this.definition.span);
     }
   }
   else if ($notnull_bool(this.isInitializer && !$notnull_bool(method.get$isConstructor()))) {
     world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
 }
 Parameter.prototype.genValue = function(method, context) {
   var $0;
   if (this.definition.value == null || this.value != null) return;
   if (context == null) {
     context = new MethodGenerator(method, null);
   }
   this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
 Parameter.prototype.copyWithNewType = function(newType) {
   var ret = new Parameter(this.definition);
-  ret.type = newType;
-  ret.name = this.name;
-  ret.isInitializer = this.isInitializer;
+  ret.set$type(newType);
+  ret.set$name(this.name);
+  ret.set$isInitializer(this.isInitializer);
   return (ret && ret.is$Parameter());
 }
 Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
 Parameter.prototype.copyWithNewType$1 = function($0) {
   return this.copyWithNewType(($0 && $0.is$lang_Type()));
 };
 Parameter.prototype.genValue$2 = function($0, $1) {
   return this.genValue(($0 && $0.is$MethodMember()), ($1 && $1.is$MethodGenerator()));
 };
 Parameter.prototype.resolve$2 = function($0, $1) {
   return this.resolve(($0 && $0.is$Member()), ($1 && $1.is$lang_Type()));
 };
 // ********** Code for Member **************
 function Member(name, declaringType) {
   this.name = name;
   this.declaringType = declaringType;
   this.isGenerated = false;
   // Initializers done
 }
 Member.prototype.is$Member = function(){return this;};
 Member.prototype.is$Named = function(){return this;};
 Member.prototype.get$name = function() { return this.name; };
+Member.prototype.get$declaringType = function() { return this.declaringType; };
+Member.prototype.get$generator = function() { return this.generator; };
+Member.prototype.set$generator = function(value) { return this.generator = value; };
 Member.prototype.get$jsname = function() {
   return this._jsname == null ? this.name : this._jsname;
 }
 Member.prototype.set$jsname = function(name) {
   return this._jsname = name;
 }
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
@@ skipping 60 matching lines @@
 Member.prototype.get$definition = function() {
   return null;
 }
 Member.prototype.get$parameters = function() {
   return [];
 }
 Member.prototype.canInvoke = function(context, args) {
   return $notnull_bool(this.get$canGet() && new Value(this.get$returnType(), null, null, true).canInvoke(context, '\$call', args));
 }
 Member.prototype.invoke = function(context, node, target, args, isDynamic) {
+  var $0;
   var newTarget = this._get(context, node, target, isDynamic);
-  return newTarget.invoke$5(context, '\$call', node, args, isDynamic);
+  return (($0 = newTarget.invoke$5(context, '\$call', node, args, isDynamic)) && $0.is$Value());
 }
 Member.prototype.override = function(other) {
   if ($notnull_bool(this.get$isStatic())) {
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
@@ skipping 44 matching lines @@
   return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for TypeMember **************
 function TypeMember(type) {
   this.type = type;
   Member.call(this, type.name, type.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.is$TypeMember = function(){return this;};
+TypeMember.prototype.get$type = function() { return this.type; };
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
   return world.varType;
 }
 TypeMember.prototype.canInvoke = function(context, args) {
   return false;
 }
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
 TypeMember.prototype.resolve = function(inType) {
 
 }
 TypeMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = new Value(this.type, this.type.get$jsname(), node.span, false);
-  ret.isType = true;
+  ret.set$isType(true);
   return (ret && ret.is$Value());
 }
 TypeMember.prototype._set = function(context, node, target, value, isDynamic) {
   world.error('can not set type', this.type.definition.span);
 }
 TypeMember.prototype.invoke = function(context, node, target, args, isDynamic) {
   world.error('can not invoke type', this.type.definition.span);
 }
 TypeMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
@@ skipping 23 matching lines @@
   this.definition = definition;
   this.value = value;
   this.isNative = false;
   Member.call(this, name, declaringType);
   // Initializers done
 }
 $inherits(FieldMember, Member);
 FieldMember.prototype.is$FieldMember = function(){return this;};
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
+FieldMember.prototype.get$type = function() { return this.type; };
+FieldMember.prototype.set$type = function(value) { return this.type = value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
+FieldMember.prototype.get$isFinal = function() { return this.isFinal; };
+FieldMember.prototype.set$isFinal = function(value) { return this.isFinal = 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(other.get$isProperty())) {
     return true;
   }
   else {
     world.error('field can not override anything but property', this.get$span(), other.get$span());
     return false;
@@ skipping 21 matching lines @@
 FieldMember.prototype.get$canGet = function() {
   return true;
 }
 FieldMember.prototype.get$canSet = function() {
   return !$notnull_bool(this.isFinal);
 }
 FieldMember.prototype.get$isField = function() {
   return true;
 }
 FieldMember.prototype.resolve = function(inType) {
+  var $0;
   this.isStatic = this.declaringType.get$isTop();
   this.isFinal = false;
   if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
-      if ($notnull_bool($eq(mod.kind, 86/*TokenKind.STATIC*/))) {
+      if ($notnull_bool($eq(mod.get$kind(), 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
-          world.error('duplicate static modifier', mod.get$span());
+          world.error('duplicate static modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isStatic = true;
       }
-      else if ($notnull_bool($eq(mod.kind, 97/*TokenKind.FINAL*/))) {
+      else if ($notnull_bool($eq(mod.get$kind(), 97/*TokenKind.FINAL*/))) {
         if ($notnull_bool(this.isFinal)) {
-          world.error('duplicate final modifier', mod.get$span());
+          world.error('duplicate final modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isFinal = true;
       }
       else {
-        world.error(('' + mod + ' modifier not allowed on field'), mod.get$span());
+        world.error(('' + mod + ' modifier not allowed on field'), (($0 = mod.get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(this.isStatic && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.type.span);
   }
   if ($notnull_bool(this.isStatic && this.isFinal) && this.value == null) {
     world.error('static final field is missing initializer', this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   var $0;
   if (this.value == null) return null;
   if (this._computedValue == null) {
     if ($notnull_bool(this._computing)) {
       world.error('circular reference', this.value.span);
       return null;
     }
     this._computing = true;
     var finalMethod = new MethodMember('final_context', this.declaringType, null);
-    finalMethod.isStatic = true;
+    finalMethod.set$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(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);
       }
     }
@@ skipping 15 matching lines @@
       return (cv && cv.is$Value());
     }
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.type, ('' + this.get$jsname() + ''), node.span, true);
     }
     else {
       return new Value(this.type, ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + ''), node.span, true);
     }
   }
   else if ($notnull_bool(target.get$isConst() && this.isFinal)) {
-    var constTarget = (target instanceof GlobalValue) ? target.get$dynamic().exp : target;
+    var constTarget = (target instanceof GlobalValue) ? target.get$dynamic().get$exp() : target;
     if ((constTarget instanceof ConstObjectValue)) {
-      return (($0 = constTarget.fields.$index(this.name)) && $0.is$Value());
+      return (($0 = constTarget.get$fields().$index(this.name)) && $0.is$Value());
     }
-    else if ($notnull_bool($eq(constTarget.type, world.stringType) && this.name == 'length')) {
+    else if ($notnull_bool($eq(constTarget.get$type(), world.stringType) && this.name == 'length')) {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), node.span, true);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), node.span, true);
 }
 FieldMember.prototype._set = function(context, node, target, value, isDynamic) {
   var lhs = this._get(context, node, target, isDynamic);
   value = value.convertTo(context, this.type, node, isDynamic);
-  return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), node.span, true);
+  return new Value(this.type, ('' + lhs.get$code() + ' = ' + value.code + ''), node.span, true);
 }
 FieldMember.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 FieldMember.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 FieldMember.prototype.computeValue$0 = function() {
   return this.computeValue();
 };
 FieldMember.prototype.provideFieldSyntax$0 = function() {
   return this.provideFieldSyntax();
 };
 FieldMember.prototype.providePropertySyntax$0 = function() {
   return this.providePropertySyntax();
 };
 FieldMember.prototype.resolve$1 = function($0) {
   return this.resolve(($0 && $0.is$lang_Type()));
 };
 // ********** Code for PropertyMember **************
 function PropertyMember(name, declaringType) {
   this._provideFieldSyntax = false
   Member.call(this, name, declaringType);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.is$PropertyMember = function(){return this;};
+PropertyMember.prototype.get$getter = function() { return this.getter; };
+PropertyMember.prototype.set$getter = function(value) { return this.getter = value; };
+PropertyMember.prototype.get$setter = function() { return this.setter; };
+PropertyMember.prototype.set$setter = function(value) { return this.setter = value; };
 PropertyMember.prototype.get$span = function() {
   var $0;
   return (($0 = this.getter != null ? this.getter.get$span() : null) && $0.is$SourceSpan());
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
 PropertyMember.prototype.get$canSet = function() {
   return this.setter != null;
 }
@@ skipping 84 matching lines @@
 // ********** Code for ConcreteMember **************
 function ConcreteMember(name, declaringType, baseMember) {
   this.baseMember = baseMember;
   Member.call(this, name, declaringType);
   // Initializers done
   this.parameters = [];
   this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
-    var newType = p.type.resolveTypeParams$1(declaringType);
-    if ($notnull_bool($ne(newType, p.type))) {
+    var newType = p.get$type().resolveTypeParams$1(declaringType);
+    if ($notnull_bool($ne(newType, p.get$type()))) {
       this.parameters.add(p.copyWithNewType$1(newType));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 $inherits(ConcreteMember, Member);
 ConcreteMember.prototype.is$ConcreteMember = function(){return this;};
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
@@ skipping 140 matching lines @@
 MethodMember.prototype.get$parameters = function() { return this.parameters; };
 MethodMember.prototype.set$parameters = function(value) { return this.parameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 MethodMember.prototype.get$isAbstract = function() { return this.isAbstract; };
 MethodMember.prototype.set$isAbstract = function(value) { return this.isAbstract = value; };
 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$isLambda = function() { return this.isLambda; };
+MethodMember.prototype.set$isLambda = function(value) { return this.isLambda = 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 !$notnull_bool(this.get$isConstructor());
 }
 MethodMember.prototype.get$isNative = function() {
   return (this.definition.body instanceof NativeStatement);
@@ skipping 90 matching lines @@
   }
   this._providePropertySyntax = true;
   return new Value(this.get$functionType(), ('' + target.code + '.get\$' + this.get$jsname() + '()'), node.span, true);
 }
 MethodMember.prototype.namesInOrder = function(args) {
   if (!$notnull_bool(args.get$hasNames())) return true;
   var lastParameter = null;
   for (var i = args.get$bareCount();
    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(p >= 0 && args.values.$index(p).get$needsTemp())) {
       if (lastParameter != null && lastParameter > $assert_num(p)) {
         return false;
       }
       lastParameter = $assert_num(p);
     }
   }
   return true;
 }
 MethodMember.prototype.needsArgumentConversion = function(args) {
   var bareCount = args.get$bareCount();
   for (var i = 0;
    i < bareCount; i++) {
     var arg = args.values.$index(i);
-    if ($notnull_bool(arg.needsConversion$1(this.parameters.$index(i).type))) {
+    if ($notnull_bool(arg.needsConversion$1(this.parameters.$index(i).get$type()))) {
       return false;
     }
   }
   if (bareCount < this.parameters.length) {
     this.genParameterValues();
     for (var i = bareCount;
      i < this.parameters.length; i++) {
       var arg = args.getValue($assert_String(this.parameters.$index(i).get$name()));
-      if ($notnull_bool($ne(arg, null) && arg.needsConversion$1(this.parameters.$index(i).type))) {
+      if ($notnull_bool($ne(arg, null) && arg.needsConversion$1(this.parameters.$index(i).get$type()))) {
         return false;
       }
     }
   }
   return true;
 }
 MethodMember._argCountMsg = function(actual, expected, atLeast) {
   return 'wrong number of arguments, expected ' + ('' + ($notnull_bool(atLeast) ? "at least " : "") + '' + expected + ' but found ' + actual + '');
 }
 MethodMember.prototype._argError = function(context, node, target, args, msg) {
   if ($notnull_bool(this.isStatic || this.get$isConstructor())) {
     world.error(msg, node.span);
   }
   else {
     world.warning(msg, node.span);
   }
   return target.invokeNoSuchMethod(context, this.name, node, args);
 }
 MethodMember.prototype.genParameterValues = function() {
   var $list = this.parameters;
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
     p.genValue$2(this, this.generator);
   }
 }
 MethodMember.prototype.invoke = function(context, node, target, args, isDynamic) {
+  var $0;
   if (this.parameters == null) {
     world.info(('surprised to need to resolve: ' + this.declaringType.name + '.' + this.name + ''));
     this.resolve(this.declaringType);
   }
   this.declaringType.genMethod(this);
   if ($notnull_bool(this.isStatic || this.isFactory)) {
     this.declaringType.markUsed();
   }
   if ($notnull_bool(this.get$isNative() && this.returnType != null)) this.returnType.markUsed();
   if (!$notnull_bool(this.namesInOrder(args))) {
     return context.findMembers(this.name).invokeOnVar(context, node, target, args);
   }
   var argsCode = [];
   if (target != null && ($notnull_bool(this.get$isConstructor() || target.isSuper))) {
     argsCode.add$1('this');
   }
   var bareCount = args.get$bareCount();
   for (var i = 0;
    i < bareCount; i++) {
     var arg = args.values.$index(i);
     if (i >= this.parameters.length) {
       var msg = MethodMember._argCountMsg(args.get$length(), this.parameters.length, false);
       return this._argError(context, node, target, args, $assert_String(msg));
     }
-    arg = arg.convertTo$4(context, this.parameters.$index(i).type, node, isDynamic);
+    arg = arg.convertTo$4(context, this.parameters.$index(i).get$type(), node, isDynamic);
     if ($notnull_bool(this.isConst && arg.get$isConst())) {
       argsCode.add$1(arg.get$canonicalCode());
     }
     else {
-      argsCode.add$1(arg.code);
+      argsCode.add$1(arg.get$code());
     }
   }
   if (bareCount < this.parameters.length) {
     this.genParameterValues();
     var namedArgsUsed = 0;
     for (var i = bareCount;
      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$4(context, this.parameters.$index(i).type, node, isDynamic);
+        arg = arg.convertTo$4(context, this.parameters.$index(i).get$type(), node, isDynamic);
         namedArgsUsed++;
       }
       if ($notnull_bool(arg == null || !$notnull_bool(this.parameters.$index(i).get$isOptional()))) {
         var msg = MethodMember._argCountMsg(Math.min(i, args.get$length()), i + 1, true);
         return this._argError(context, node, target, args, $assert_String(msg));
       }
       else {
-        argsCode.add$1($notnull_bool(this.isConst && arg.get$isConst()) ? arg.get$canonicalCode() : arg.code);
+        argsCode.add$1($notnull_bool(this.isConst && arg.get$isConst()) ? arg.get$canonicalCode() : arg.get$code());
       }
     }
     if (namedArgsUsed < args.get$nameCount()) {
       var seen = new HashSetImplementation();
       for (var i = bareCount;
        i < args.get$length(); i++) {
         var name = args.getName(i);
         if ($notnull_bool(seen.contains$1(name))) {
           return this._argError(context, node, target, args, ('duplicate argument "' + name + '"'));
         }
@@ skipping 25 matching lines @@
   }
   if ($notnull_bool(this.isStatic)) {
     if ($notnull_bool(this.declaringType.get$isTop())) {
       return new Value(this.get$inferredResult(), ('' + this.get$jsname() + '(' + argsString + ')'), node != null ? node.span : node, true);
     }
     return new Value(this.get$inferredResult(), ('' + this.declaringType.get$jsname() + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
   }
   var code = ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')');
   if ($notnull_bool(target.get$isConst())) {
     if ((target instanceof GlobalValue)) {
-      target = target.get$dynamic().exp;
+      target = (($0 = target.get$dynamic().get$exp()) && $0.is$Value());
     }
     if (this.name == 'get\$length') {
       if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
-        code = ('' + target.get$dynamic().values.length + '');
+        code = ('' + target.get$dynamic().get$values().length + '');
       }
     }
     else if (this.name == 'isEmpty') {
       if ((target instanceof ConstListValue) || (target instanceof ConstMapValue)) {
-        code = ('' + target.get$dynamic().values.isEmpty$0() + '');
+        code = ('' + target.get$dynamic().get$values().isEmpty$0() + '');
       }
     }
   }
   if (this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), world.get$dom())) {
     world.gen.corejs.useTypeNameOf = true;
   }
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
   this.declaringType.markUsed();
@@ skipping 10 matching lines @@
       return new Value(this.declaringType, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
   var $0;
   var fields = new HashMapImplementation();
   for (var i = 0;
    i < this.parameters.length; i++) {
     var param = this.parameters.$index(i);
-    if ($notnull_bool(param.isInitializer)) {
+    if ($notnull_bool(param.get$isInitializer())) {
       var value = null;
       if (i < args.get$length()) {
         value = args.values.$index(i);
       }
       else {
         value = args.getValue($assert_String(param.get$name()));
         if ($notnull_bool(value == null)) {
           value = param.get$value();
         }
       }
@@ skipping 16 matching lines @@
         }
       }
       this.generator._scope._vars.$setindex(name, value);
     }
     var $list = this.definition.initializers;
     for (var $i = 0;$i < $list.length; $i++) {
       var init = $list.$index($i);
       if ((init instanceof CallExpression)) {
         var delegateArgs = this.generator._makeArgs((($0 = init.get$arguments()) && $0.is$List$ArgumentNode()));
         var value = this.initDelegate.invoke(this.generator, node, target, delegateArgs, false);
-        if ((init.target instanceof ThisExpression)) {
+        if ((init.get$target() instanceof ThisExpression)) {
           return (value && value.is$Value());
         }
         else {
           if ((value instanceof GlobalValue)) {
-            value = value.exp;
+            value = value.get$exp();
           }
-          var $list0 = value.fields.getKeys();
-          for (var $i0 = value.fields.getKeys().iterator$0(); $i0.hasNext$0(); ) {
+          var $list0 = value.get$fields().getKeys$0();
+          for (var $i0 = value.get$fields().getKeys$0().iterator$0(); $i0.hasNext$0(); ) {
             var fname = $i0.next$0();
-            fields.$setindex(fname, value.fields.$index(fname));
+            fields.$setindex(fname, value.get$fields().$index(fname));
           }
         }
       }
       else {
         var assign = (init && init.is$BinaryExpression());
         var x = (($0 = assign.x) && $0.is$VarExpression());
         var fname = x.name.name;
         var val = this.generator.visitValue(assign.y);
         fields.$setindex(fname, val);
       }
@@ skipping 149 matching lines @@
   }
   else if ($notnull_bool(this.declaringType.get$isString())) {
     if (this.name == '\$index') {
       return new Value(this.declaringType, ('' + target.code + '[' + argsCode.$index(0) + ']'), node.span, true);
     }
     else if (this.name == '\$add') {
       if ($notnull_bool(allConst)) {
         var val0 = target.get$dynamic().get$actualValue();
         val0 = val0.substring$2(1, val0.length - 1);
         var val1 = args.values.$index(0).get$dynamic().get$actualValue();
-        if ($notnull_bool(args.values.$index(0).type.get$isString())) {
+        if ($notnull_bool(args.values.$index(0).get$type().get$isString())) {
           val1 = val1.substring$2(1, val1.length - 1);
         }
         var value = ('' + val0 + '' + val1 + '');
         value = '"' + value.replaceAll$2('"', '\\"') + '"';
         return EvaluatedValue.EvaluatedValue$factory(world.stringType, value, $assert_String(value), node.span);
       }
       args.values.$index(0).invoke$4(context, 'toString', node, Arguments.get$EMPTY());
       return new Value(this.declaringType, ('' + target.code + ' + ' + argsCode.$index(0) + ''), node.span, true);
     }
   }
@@ skipping 32 matching lines @@
   if (this.name == '\$index') {
     world.gen.corejs.useIndex = true;
   }
   else if (this.name == '\$setindex') {
     world.gen.corejs.useSetIndex = true;
   }
   var argsString = Strings.join((argsCode && argsCode.is$List$String()), ', ');
   return new Value(this.get$inferredResult(), ('' + target.code + '.' + this.get$jsname() + '(' + argsString + ')'), node.span, true);
 }
 MethodMember.prototype.resolve = function(inType) {
+  var $0;
   this.isStatic = inType.get$isTop();
   this.isConst = false;
   this.isFactory = false;
   this.isAbstract = !$notnull_bool(this.declaringType.get$isClass());
   if (this.definition.modifiers != null) {
     var $list = this.definition.modifiers;
     for (var $i = 0;$i < $list.length; $i++) {
       var mod = $list.$index($i);
-      if ($notnull_bool($eq(mod.kind, 86/*TokenKind.STATIC*/))) {
+      if ($notnull_bool($eq(mod.get$kind(), 86/*TokenKind.STATIC*/))) {
         if ($notnull_bool(this.isStatic)) {
-          world.error('duplicate static modifier', mod.get$span());
+          world.error('duplicate static modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isStatic = true;
       }
-      else if ($notnull_bool(this.get$isConstructor() && $eq(mod.kind, 91/*TokenKind.CONST*/))) {
+      else if ($notnull_bool(this.get$isConstructor() && $eq(mod.get$kind(), 91/*TokenKind.CONST*/))) {
         if ($notnull_bool(this.isConst)) {
-          world.error('duplicate const modifier', mod.get$span());
+          world.error('duplicate const modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isConst = true;
       }
-      else if ($notnull_bool($eq(mod.kind, 75/*TokenKind.FACTORY*/))) {
+      else if ($notnull_bool($eq(mod.get$kind(), 75/*TokenKind.FACTORY*/))) {
         if ($notnull_bool(this.isFactory)) {
-          world.error('duplicate factory modifier', mod.get$span());
+          world.error('duplicate factory modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
         }
         this.isFactory = true;
       }
-      else if ($notnull_bool($eq(mod.kind, 71/*TokenKind.ABSTRACT*/))) {
+      else if ($notnull_bool($eq(mod.get$kind(), 71/*TokenKind.ABSTRACT*/))) {
         if ($notnull_bool(this.isAbstract)) {
           if ($notnull_bool(this.declaringType.get$isClass())) {
-            world.error('duplicate abstract modifier', mod.get$span());
+            world.error('duplicate abstract modifier', (($0 = mod.get$span()) && $0.is$SourceSpan()));
           }
           else {
-            world.error('abstract modifier not allowed on interface members', mod.get$span());
+            world.error('abstract modifier not allowed on interface members', (($0 = mod.get$span()) && $0.is$SourceSpan()));
           }
         }
         this.isAbstract = true;
       }
       else {
-        world.error(('' + mod + ' modifier not allowed on method'), mod.get$span());
+        world.error(('' + mod + ' modifier not allowed on method'), (($0 = mod.get$span()) && $0.is$SourceSpan()));
       }
     }
   }
   if ($notnull_bool(this.isFactory)) {
     this.isStatic = true;
   }
   if ($notnull_bool(this.get$isOperator() && this.isStatic) && !$notnull_bool(this.get$isCallMethod())) {
     world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if ($notnull_bool(this.isAbstract)) {
@@ skipping 82 matching lines @@
   })
   );
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.get$isStatic = function() {
   return $notnull_bool(this.members.length == 1 && this.members.$index(0).get$isStatic());
 }
 MemberSet.prototype.get$isOperator = function() {
-  return this.members.$index(0).get$isOperator();
+  return $assert_bool(this.members.$index(0).get$isOperator());
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if (!$notnull_bool(target.type.get$isVar())) {
     world.warning(('could not find applicable ' + action + ' for "' + this.name + '"'), node.span);
   }
   return new Value(world.varType, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), node.span, true);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if (this._treatAsField == null) {
-    this._treatAsField = true;
+    this._treatAsField = !$notnull_bool(this.isVar);
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(member.get$requiresFieldSyntax())) {
         this._treatAsField = true;
         break;
       }
       if ($notnull_bool(member.get$prefersPropertySyntax())) {
         this._treatAsField = false;
       }
     }
     var $list = this.members;
     for (var $i = 0;$i < $list.length; $i++) {
       var member = $list.$index($i);
       if ($notnull_bool(this._treatAsField)) {
         member.provideFieldSyntax$0();
       }
       else {
         member.providePropertySyntax$0();
       }
     }
   }
   return this._treatAsField;
 }
 MemberSet.prototype._get = function(context, node, target, isDynamic) {
-  if (this.members.length == 1) {
-    return this.members.$index(0)._get(context, node, target, isDynamic);
-  }
+  var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canGet();
   })
   );
-  if (targets.length == 1) {
-    return targets.$index(0)._get(context, node, target, isDynamic);
+  if ($notnull_bool(this.isVar)) {
+    targets.forEach$1((function (m) {
+      return m._get(context, node, target, true);
+    })
+    );
+    returnValue = new Value(this._foldTypes((targets && targets.is$List$Member())), null, node.span, true);
   }
-  var returnValue = null;
-  for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
-    var member = $i.next$0();
-    var value = member._get(context, node, target, true);
-    returnValue = this._tryUnion(returnValue, value, node);
-  }
-  if (returnValue == null) {
-    return this._makeError(node, target, 'getter');
+  else {
+    if (this.members.length == 1) {
+      return this.members.$index(0)._get(context, node, target, isDynamic);
+    }
+    else if ($notnull_bool($eq(targets.length, 1))) {
+      return targets.$index(0)._get(context, node, target, isDynamic);
+    }
+    for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
+      var member = $i.next$0();
+      var value = member._get(context, node, target, true);
+      returnValue = this._tryUnion(returnValue, value, node);
+    }
+    if (returnValue == null) {
+      return this._makeError(node, target, 'getter');
+    }
   }
   if (returnValue.code == null) {
     if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ''), node.span, true);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.get\$' + this.jsname + '()'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype._set = function(context, node, target, value, isDynamic) {
-  if (this.members.length == 1) {
-    return this.members.$index(0)._set(context, node, target, value, isDynamic);
-  }
+  var returnValue;
   var targets = this.members.filter((function (m) {
     return m.get$canSet();
   })
   );
-  if (targets.length == 1) {
-    return targets.$index(0)._set(context, node, target, value, isDynamic);
+  if ($notnull_bool(this.isVar)) {
+    targets.forEach$1((function (m) {
+      return m._set(context, node, target, value, true);
+    })
+    );
+    returnValue = new Value(this._foldTypes((targets && targets.is$List$Member())), null, node.span, true);
   }
-  var returnValue = null;
-  for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
-    var member = $i.next$0();
-    var res = member._set(context, node, target, value, true);
-    returnValue = this._tryUnion(returnValue, res, node);
-  }
-  if (returnValue == null) {
-    return this._makeError(node, target, 'setter');
+  else {
+    if (this.members.length == 1) {
+      return this.members.$index(0)._set(context, node, target, value, isDynamic);
+    }
+    else if ($notnull_bool($eq(targets.length, 1))) {
+      return targets.$index(0)._set(context, node, target, value, isDynamic);
+    }
+    for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
+      var member = $i.next$0();
+      var res = member._set(context, node, target, value, true);
+      returnValue = this._tryUnion(returnValue, res, node);
+    }
+    if (returnValue == null) {
+      return this._makeError(node, target, 'setter');
+    }
   }
   if (returnValue.code == null) {
     if ($notnull_bool(this.get$treatAsField())) {
       return new Value(returnValue.type, ('' + target.code + '.' + this.jsname + ' = ' + value.code + ''), node.span, true);
     }
     else {
       return new Value(returnValue.type, ('' + target.code + '.set\$' + this.jsname + '(' + value.code + ')'), node.span, true);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invoke = function(context, node, target, args, isDynamic) {
   var $0;
   if ($notnull_bool(this.isVar && !$notnull_bool(this.get$isOperator()))) {
     return this.invokeOnVar(context, node, target, args);
   }
   if (this.members.length == 1) {
-    return this.members.$index(0).invoke$5(context, node, target, args, isDynamic);
+    return (($0 = this.members.$index(0).invoke$5(context, node, target, args, isDynamic)) && $0.is$Value());
   }
   var targets = this.members.filter((function (m) {
     return m.canInvoke$2(context, args);
   })
   );
-  if (targets.length == 1) {
+  if ($notnull_bool($eq(targets.length, 1))) {
     return (($0 = targets.$index(0).invoke$5(context, node, target, args, isDynamic)) && $0.is$Value());
   }
   var returnValue = null;
   for (var $i = targets.iterator$0(); $i.hasNext$0(); ) {
     var member = $i.next$0();
     var res = member.invoke$4$isDynamic(context, node, target, args, true);
-    returnValue = this._tryUnion(returnValue, res, node);
+    returnValue = this._tryUnion(returnValue, (res && res.is$Value()), node);
   }
   if (returnValue == null) {
     return this._makeError(node, target, 'method');
   }
   if (returnValue.code == null) {
     if ($notnull_bool(this.get$isOperator())) {
       return target.invokeSpecial(this.name, args, returnValue.type);
     }
     else {
       return this.invokeOnVar(context, node, target, args);
     }
   }
   return returnValue;
 }
 MemberSet.prototype.invokeOnVar = function(context, node, target, args) {
+  var $0;
   var member = this.getVarMember(context, node, args);
-  return member.invoke$4(context, node, target, args);
+  return (($0 = member.invoke$4(context, node, target, args)) && $0.is$Value());
 }
 MemberSet.prototype._tryUnion = function(x, y, node) {
   if (x == null) return y;
   var type = lang_Type.union(x.type, y.type);
   if (x.code == y.code) {
     if ($notnull_bool($eq(type, x.type))) {
       return x;
     }
     else if ($notnull_bool(x.get$isConst() || y.get$isConst())) {
       world.internalError("unexpected: union of const values ");
     }
     else {
       var ret = new Value(type, x.code, node.span, true);
-      ret.isSuper = $notnull_bool(x.isSuper && y.isSuper);
-      ret.needsTemp = $notnull_bool(x.needsTemp || y.needsTemp);
-      ret.isType = $notnull_bool(x.isType && y.isType);
+      ret.set$isSuper($notnull_bool(x.isSuper && y.isSuper));
+      ret.set$needsTemp($notnull_bool(x.needsTemp || y.needsTemp));
+      ret.set$isType($notnull_bool(x.isType && y.isType));
       return (ret && ret.is$Value());
     }
   }
   else {
     return new Value(type, null, node.span, true);
   }
 }
 MemberSet.prototype.getVarMember = function(context, node, args) {
   if (world.objectType.varStubs == null) {
     world.objectType.varStubs = $map([]);
   }
   var stubName = _getCallStubName(this.name, args);
   var stub = world.objectType.varStubs.$index(stubName);
   if ($notnull_bool(stub == null)) {
     var mset = context.findMembers(this.name).members;
     var targets = mset.filter((function (m) {
       return m.canInvoke$2(context, args);
     })
     );
-    var returnType = reduce(map((targets && targets.is$Iterable()), (function (t) {
-      return t.get$returnType();
-    })
-    ), lang_Type.union);
-    stub = new VarMethodSet($assert_String(stubName), targets, args, returnType);
+    stub = new VarMethodSet($assert_String(stubName), targets, args, this._foldTypes((targets && targets.is$List$Member())));
     world.objectType.varStubs.$setindex(stubName, stub);
   }
   return (stub && stub.is$VarMember());
 }
+MemberSet.prototype._foldTypes = function(targets) {
+  var $0;
+  return (($0 = reduce(map(targets, (function (t) {
+    return t.get$returnType();
+  })
+  ), lang_Type.union, world.varType)) && $0.is$lang_Type());
+}
 MemberSet.prototype._get$3 = function($0, $1, $2) {
   return this._get(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 };
 MemberSet.prototype._set$4 = function($0, $1, $2, $3) {
   return this._set(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Value()), false);
 };
 MemberSet.prototype.add$1 = function($0) {
   return this.add(($0 && $0.is$Member()));
 };
 MemberSet.prototype.canInvoke$2 = function($0, $1) {
@@ skipping 33 matching lines @@
 }
 FactoryMap.prototype.forEach = function(f) {
   this.factories.forEach((function (_, constructors) {
     constructors.forEach((function (_, member) {
       f(member);
     })
     );
   })
   );
 }
+FactoryMap.prototype.forEach$1 = FactoryMap.prototype.forEach;
 FactoryMap.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory($assert_String($0), $assert_String($1));
 };
 // ********** Code for lang_Token **************
 function lang_Token(kind, source, start, end) {
   this.kind = kind;
   this.source = source;
   this.start = start;
   this.end = end;
   // Initializers done
 }
+lang_Token.prototype.get$kind = function() { return this.kind; };
+lang_Token.prototype.get$end = function() { return this.end; };
+lang_Token.prototype.get$start = function() { return this.start; };
 lang_Token.prototype.get$text = function() {
   return this.source.get$text().substring(this.start, this.end);
 }
 lang_Token.prototype.toString = function() {
   var kindText = TokenKind.kindToString(this.kind);
   var actualText = this.get$text();
   if ($notnull_bool($ne(kindText, actualText))) {
     if (actualText.length > 10) {
       actualText = actualText.substring$2(0, 8) + '...';
     }
@@ skipping 10 matching lines @@
   return this.toString();
 };
 // ********** Code for SourceFile **************
 function SourceFile(filename, _text) {
   this.filename = filename;
   this._text = _text;
   // Initializers done
 }
 SourceFile.prototype.is$SourceFile = function(){return this;};
 SourceFile.prototype.is$Comparable = function(){return this;};
+SourceFile.prototype.get$filename = function() { return this.filename; };
+SourceFile.prototype.get$orderInLibrary = function() { return this.orderInLibrary; };
+SourceFile.prototype.set$orderInLibrary = function(value) { return this.orderInLibrary = value; };
 SourceFile.prototype.get$text = function() {
   return this._text;
 }
 SourceFile.prototype.get$lineStarts = function() {
   if (this._lineStarts == null) {
     var starts = [0];
     var index = 0;
     while (index < this.get$text().length) {
       index = this.get$text().indexOf('\n', index) + 1;
       if (index <= 0) break;
       starts.add$1(index);
     }
     starts.add$1(this.get$text().length + 1);
     this._lineStarts = (starts && starts.is$List$int());
   }
   return this._lineStarts;
 }
 SourceFile.prototype.getLine = function(position) {
   var starts = this.get$lineStarts();
   for (var i = 0;
-   i < starts.length; i++) {
+   i < $assert_num(starts.length); i++) {
     if (starts.$index(i) > position) return i - 1;
   }
   world.internalError('bad position');
 }
 SourceFile.prototype.getColumn = function(line, position) {
   return position - $assert_num(this.get$lineStarts().$index(line));
 }
 SourceFile.prototype.getLocationMessage = function(message, start, end, includeText) {
   var line = this.getLine(start);
   var column = this.getColumn($assert_num(line), start);
   var buf = new StringBufferImpl(('' + this.filename + ':' + (line + 1) + ':' + (column + 1) + ': ' + message + ''));
   if ($notnull_bool(includeText)) {
     buf.add$1('\n');
     var textLine;
     if ((line + 2) < this._lineStarts.length) {
       textLine = this.get$text().substring(this._lineStarts.$index(line), this._lineStarts.$index(line + 1));
     }
     else {
       textLine = this.get$text().substring(this._lineStarts.$index(line)) + '\n';
     }
     buf.add$1(textLine);
     var i = 0;
     for (; i < $assert_num(column); i++) {
       buf.add$1(' ');
     }
-    var toColumn = Math.min($assert_num(column + (end - start)), textLine.length);
+    var toColumn = Math.min($assert_num(column + (end - start)), $assert_num(textLine.length));
     for (; i < toColumn; i++) {
       buf.add$1('^');
     }
   }
   return buf.toString$0();
 }
 SourceFile.prototype.compareTo = function(other) {
   if (this.orderInLibrary != null && other.orderInLibrary != null) {
     return this.orderInLibrary - other.orderInLibrary;
   }
   else {
     return this.filename.compareTo(other.filename);
   }
 }
 SourceFile.prototype.compareTo$1 = function($0) {
   return this.compareTo(($0 && $0.is$SourceFile()));
 };
+SourceFile.prototype.getColumn$2 = function($0, $1) {
+  return this.getColumn($assert_num($0), $assert_num($1));
+};
+SourceFile.prototype.getLine$1 = function($0) {
+  return this.getLine($assert_num($0));
+};
 // ********** Code for SourceSpan **************
 function SourceSpan(file, start, end) {
   this.file = file;
   this.start = start;
   this.end = end;
   // Initializers done
 }
 SourceSpan.prototype.is$SourceSpan = function(){return this;};
 SourceSpan.prototype.is$Comparable = function(){return this;};
+SourceSpan.prototype.get$file = function() { return this.file; };
+SourceSpan.prototype.get$start = function() { return this.start; };
+SourceSpan.prototype.get$end = function() { return this.end; };
 SourceSpan.prototype.get$text = function() {
   return this.file.get$text().substring(this.start, this.end);
 }
 SourceSpan.prototype.toMessageString = function(message) {
   return this.file.getLocationMessage(message, this.start, this.end, true);
 }
 SourceSpan.prototype.get$locationText = function() {
   var line = this.file.getLine(this.start);
   var column = this.file.getColumn($assert_num(line), this.start);
   return ('' + this.file.filename + ':' + (line + 1) + ':' + (column + 1) + '');
@@ skipping 10 matching lines @@
 };
 // ********** Code for InterpStack **************
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = -1;
   // Initializers done
 }
 InterpStack.prototype.is$InterpStack = function(){return this;};
+InterpStack.prototype.get$previous = function() { return this.previous; };
+InterpStack.prototype.set$previous = function(value) { return this.previous = value; };
+InterpStack.prototype.get$quote = function() { return this.quote; };
+InterpStack.prototype.get$isMultiline = function() { return this.isMultiline; };
+InterpStack.prototype.get$depth = function() { return this.depth; };
+InterpStack.prototype.set$depth = function(value) { return this.depth = value; };
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
 InterpStack.push = function(stack, quote, isMultiline) {
   var newStack = new InterpStack(stack, quote, isMultiline);
-  if (stack != null) newStack.previous = stack;
+  if (stack != null) newStack.set$previous(stack);
   return (newStack && newStack.is$InterpStack());
 }
 InterpStack.prototype.next$0 = function() {
   return this.next();
 };
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._lang_index = _index;
@@ skipping 330 matching lines @@
 function Tokenizer(source, skipWhitespace, index) {
   TokenizerBase.call(this, source, skipWhitespace, index);
   // Initializers done
 }
 $inherits(Tokenizer, TokenizerBase);
 Tokenizer.prototype.next = function() {
   this._startIndex = this._lang_index;
   if (this._interpStack != null && this._interpStack.depth == 0) {
     var istack = this._interpStack;
     this._interpStack = this._interpStack.pop();
-    if ($notnull_bool(istack.isMultiline)) {
-      return this.finishMultilineString(istack.quote);
+    if ($notnull_bool(istack.get$isMultiline())) {
+      return this.finishMultilineString($assert_num(istack.get$quote()));
     }
     else {
-      return this.finishStringBody(istack.quote);
+      return this.finishStringBody($assert_num(istack.get$quote()));
     }
   }
   var ch;
   ch = this._nextChar();
   switch (ch) {
     case 0:
 
       return this._finishToken(1/*TokenKind.END_OF_FILE*/);
 
     case 32:
@@ skipping 1373 matching lines @@
 lang_Parser.prototype._eat = function(kind) {
   if (!$notnull_bool(this._maybeEat(kind))) {
     this._errorExpected(TokenKind.kindToString(kind));
   }
 }
 lang_Parser.prototype._eatSemicolon = function() {
   if ($notnull_bool(this.optionalSemicolons && this._peekKind(1/*TokenKind.END_OF_FILE*/))) return;
   this._eat(10/*TokenKind.SEMICOLON*/);
 }
 lang_Parser.prototype._errorExpected = function(expected) {
+  var $0;
   if ($notnull_bool(this.throwOnIncomplete)) this.isPrematureEndOfFile();
   var tok = this._lang_next();
   var message = ('expected ' + expected + ', but found ' + tok + '');
-  this._lang_error($assert_String(message), tok.get$span());
+  this._lang_error($assert_String(message), (($0 = tok.get$span()) && $0.is$SourceSpan()));
 }
 lang_Parser.prototype._lang_error = function(message, location) {
   if (location == null) {
     location = this._peekToken.get$span();
   }
   world.fatal(message, location);
 }
 lang_Parser.prototype._skipBlock = function() {
+  var $0;
   var depth = 1;
   this._eat(6/*TokenKind.LBRACE*/);
   while (true) {
     var tok = this._lang_next();
-    if ($notnull_bool($eq(tok.kind, 6/*TokenKind.LBRACE*/))) {
+    if ($notnull_bool($eq(tok.get$kind(), 6/*TokenKind.LBRACE*/))) {
       depth += 1;
     }
-    else if ($notnull_bool($eq(tok.kind, 7/*TokenKind.RBRACE*/))) {
+    else if ($notnull_bool($eq(tok.get$kind(), 7/*TokenKind.RBRACE*/))) {
       depth -= 1;
       if (depth == 0) return;
     }
-    else if ($notnull_bool($eq(tok.kind, 1/*TokenKind.END_OF_FILE*/))) {
-      this._lang_error('unexpected end of file during diet parse', tok.get$span());
+    else if ($notnull_bool($eq(tok.get$kind(), 1/*TokenKind.END_OF_FILE*/))) {
+      this._lang_error('unexpected end of file during diet parse', (($0 = tok.get$span()) && $0.is$SourceSpan()));
       return;
     }
   }
 }
 lang_Parser.prototype._makeSpan = function(start) {
   return new SourceSpan(this.source, start, this._previousToken.end);
 }
 lang_Parser.prototype.compilationUnit = function() {
   var ret = [];
   this._maybeEat(13/*TokenKind.HASHBANG*/);
@@ skipping 72 matching lines @@
 lang_Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
-  var func = new FunctionDefinition(null, di.type, di.get$name(), formals, null, null, this._makeSpan(start));
+  var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
 lang_Parser.prototype.initializers = function() {
   this._inInitializers = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   this._inInitializers = false;
   return ret;
 }
+lang_Parser.prototype.get$initializers = function() {
+  return lang_Parser.prototype.initializers.bind(this);
+}
 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)) {
       this._eatSemicolon();
     }
     return new ReturnStatement(expr, this._makeSpan(start));
   }
   else if ($notnull_bool(this._peekKind(6/*TokenKind.LBRACE*/))) {
@@ skipping 41 matching lines @@
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
         inits = this.initializers();
       }
       var body = this.functionBody(false);
       if ($notnull_bool(di.get$name() == null)) {
-        di.name = di.type.get$name();
+        di.set$name(di.get$type().get$name());
       }
-      return new FunctionDefinition(modifiers, di.type, di.get$name(), formals, inits, body, this._makeSpan($assert_num(start)));
+      return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, inits, body, this._makeSpan($assert_num(start)));
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
-      return this.finishField(start, modifiers, di.type, di.get$name(), value);
+      return this.finishField(start, modifiers, di.get$type(), di.get$name(), value);
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
-      return this.finishField(start, modifiers, di.type, di.get$name(), null);
+      return this.finishField(start, modifiers, di.get$type(), di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
 lang_Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if ($notnull_bool(this._peekKind(75/*TokenKind.FACTORY*/))) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
   return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
 lang_Parser.prototype.factoryConstructorDeclaration = function() {
+  var $0;
   var start = this._peekToken.start;
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     names.add$1(this.identifier());
   }
   var typeParams = null;
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     typeParams = this.typeParameters();
   }
   var name = null;
   var type = null;
   if ($notnull_bool(this._maybeEat(14/*TokenKind.DOT*/))) {
     name = this.identifier();
   }
   else if ($notnull_bool(typeParams == null)) {
     if (names.length > 1) {
       name = names.removeLast$0();
     }
     else {
-      name = new lang_Identifier('', names.$index(0).get$span());
+      name = new lang_Identifier('', (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
     }
   }
   else {
-    name = new lang_Identifier('', names.$index(0).get$span());
+    name = new lang_Identifier('', (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   }
   if (names.length > 1) {
-    this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
+    this._lang_error('unsupported qualified name for factory', (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   }
-  type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
+  type = new NameTypeReference(false, names.$index(0), null, (($0 = names.$index(0).get$span()) && $0.is$SourceSpan()));
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 lang_Parser.prototype.statement = function() {
   var $0;
   switch (this._peek()) {
     case 88/*TokenKind.BREAK*/:
 
       return (($0 = this.breakStatement()) && $0.is$lang_Statement());
 
@@ skipping 54 matching lines @@
       return (($0 = this.declaration(false)) && $0.is$lang_Statement());
 
     default:
 
       return (($0 = this.finishExpressionAsStatement(this.expression())) && $0.is$lang_Statement());
 
   }
 }
 lang_Parser.prototype.finishExpressionAsStatement = function(expr) {
   var $0;
-  var start = expr.get$span().start;
+  var start = $assert_num(expr.get$span().get$start());
   if ($notnull_bool(this._maybeEat(8/*TokenKind.COLON*/))) {
     var label = this._makeLabel(expr);
     return new LabeledStatement(label, this.statement(), this._makeSpan(start));
   }
   if ((expr instanceof LambdaExpression)) {
-    if (!(expr.func.body instanceof BlockStatement)) {
+    if (!(expr.get$func().get$body() instanceof BlockStatement)) {
       this._eatSemicolon();
-      expr.func.span = this._makeSpan(start);
+      expr.get$func().set$span(this._makeSpan(start));
     }
-    return expr.func;
+    return expr.get$func();
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
-    return this.finishField(start, null, expr.type, expr.get$name(), value);
+    return this.finishField(start, null, expr.get$type(), expr.get$name(), value);
   }
-  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
-    var di = (($0 = expr.x) && $0.is$DeclaredIdentifier());
-    return this.finishField(start, null, di.type, di.name, expr.y);
+  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.get$x() instanceof DeclaredIdentifier)))) {
+    var di = (($0 = expr.get$x()) && $0.is$DeclaredIdentifier());
+    return this.finishField(start, null, di.type, di.name, expr.get$y());
   }
   else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/) && this._maybeEat(11/*TokenKind.COMMA*/))) {
-    var baseType = this._makeType(expr.x);
-    var typeArgs = [this._makeType(expr.y)];
+    var baseType = this._makeType(expr.get$x());
+    var typeArgs = [this._makeType(expr.get$y())];
     var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
       value = this.expression();
     }
-    return this.finishField(expr.get$span().start, null, gt, name, value);
+    return this.finishField(expr.get$span().get$start(), null, gt, name, value);
   }
   else {
     this._eatSemicolon();
-    return new lang_ExpressionStatement(expr, this._makeSpan(expr.get$span().start));
+    return new lang_ExpressionStatement(expr, this._makeSpan($assert_num(expr.get$span().get$start())));
   }
 }
 lang_Parser.prototype.testCondition = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
   return (ret && ret.is$lang_Expression());
 }
 lang_Parser.prototype.block = function() {
   var start = this._peekToken.start;
@@ skipping 63 matching lines @@
 }
 lang_Parser.prototype.forInitializerStatement = function(start) {
   var $0;
   if ($notnull_bool(this._maybeEat(10/*TokenKind.SEMICOLON*/))) {
     return null;
   }
   else {
     var init = this.expression();
     if ($notnull_bool(this._peekKind(11/*TokenKind.COMMA*/) && this._isBin(init, 52/*TokenKind.LT*/))) {
       this._eat(11/*TokenKind.COMMA*/);
-      var baseType = this._makeType(init.x);
-      var typeArgs = [this._makeType(init.y)];
+      var baseType = this._makeType(init.get$x());
+      var typeArgs = [this._makeType(init.get$y())];
       var gt = this._finishTypeArguments((baseType && baseType.is$TypeReference()), 0, typeArgs);
       var name = this.identifier();
-      init = new DeclaredIdentifier(gt, name, this._makeSpan(init.get$span().start));
+      init = new DeclaredIdentifier(gt, name, this._makeSpan($assert_num(init.get$span().get$start())));
     }
     if ($notnull_bool(this._maybeEat(101/*TokenKind.IN*/))) {
       return this._finishForIn(start, (($0 = this._makeDeclaredIdentifier(init)) && $0.is$DeclaredIdentifier()));
     }
     else {
       return this.finishExpressionAsStatement(init);
     }
   }
 }
 lang_Parser.prototype._finishForIn = function(start, di) {
@@ skipping 58 matching lines @@
       this._eat(8/*TokenKind.COLON*/);
     }
     else if ($notnull_bool(this._maybeEat(93/*TokenKind.DEFAULT*/))) {
       cases.add$1();
       this._eat(8/*TokenKind.COLON*/);
     }
     else {
       break;
     }
   }
-  if (cases.length == 0) {
+  if ($notnull_bool($eq(cases.length, 0))) {
     this._lang_error('case or default');
   }
   var stmts = [];
   while (!$notnull_bool(this._peekCaseEnd())) {
     if ($notnull_bool(this.isPrematureEndOfFile())) break;
     stmts.add$1(this.statement());
   }
   return new CaseNode(label, cases, stmts, this._makeSpan(start));
 }
 lang_Parser.prototype.returnStatement = function() {
@@ skipping 48 matching lines @@
   if ($notnull_bool(this._peekIdentifier())) {
     name = this.identifier();
   }
   this._eatSemicolon();
   return new ContinueStatement(name, this._makeSpan(start));
 }
 lang_Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
 lang_Parser.prototype._makeType = function(expr) {
+  var $0;
   if ((expr instanceof VarExpression)) {
-    return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
+    return new NameTypeReference(false, expr.get$name(), null, (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
   else if ((expr instanceof DotExpression)) {
-    var type = this._makeType(expr.self);
-    if (type.names == null) {
-      type.names = [expr.get$name()];
+    var type = this._makeType(expr.get$self());
+    if (type.get$names() == null) {
+      type.set$names([expr.get$name()]);
     }
     else {
-      type.names.add(expr.get$name());
+      type.get$names().add$1(expr.get$name());
     }
-    type.span = expr.get$span();
+    type.set$span(expr.get$span());
     return type;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
 lang_Parser.prototype.infixExpression = function(precedence) {
   var $0;
   return this.finishInfixExpression((($0 = this.unaryExpression()) && $0.is$lang_Expression()), precedence);
 }
 lang_Parser.prototype._finishDeclaredId = function(type) {
   var name = this.identifier();
-  return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().start)));
+  return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan($assert_num(type.get$span().get$start()))));
 }
 lang_Parser.prototype._fixAsType = function(x) {
   $assert(this._isBin(x, 52/*TokenKind.LT*/), "_isBin(x, TokenKind.LT)", "parser.dart", 790, 12);
   if ($notnull_bool(this._maybeEat(53/*TokenKind.GT*/))) {
     var base = this._makeType(x.x);
     var typeParam = this._makeType(x.y);
     var type = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
     return this._finishDeclaredId(type);
   }
   else {
     $assert(this._peekKind(52/*TokenKind.LT*/), "_peekKind(TokenKind.LT)", "parser.dart", 801, 14);
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments((paramBase && paramBase.is$TypeReference()), 1);
     var type;
-    if (firstParam.depth <= 0) {
+    if (firstParam.get$depth() <= 0) {
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/))) {
       type = this._finishTypeArguments((base && base.is$TypeReference()), 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
       type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     return this._finishDeclaredId(type);
   }
 }
 lang_Parser.prototype.finishInfixExpression = function(x, precedence) {
   while (true) {
     var kind = this._peek();
     var prec = TokenKind.infixPrecedence(this._peek());
     if (prec >= precedence) {
       if (kind == 52/*TokenKind.LT*/ || kind == 53/*TokenKind.GT*/) {
         if ($notnull_bool(this._isBin(x, 52/*TokenKind.LT*/))) {
           return this._fixAsType((x && x.is$BinaryExpression()));
         }
       }
       var op = this._lang_next();
-      if ($notnull_bool($eq(op.kind, 102/*TokenKind.IS*/))) {
+      if ($notnull_bool($eq(op.get$kind(), 102/*TokenKind.IS*/))) {
         var isTrue = !$notnull_bool(this._maybeEat(19/*TokenKind.NOT*/));
         var typeRef = this.type(0);
         x = new IsExpression(isTrue, x, typeRef, this._makeSpan(x.span.start));
         continue;
       }
       var y = this.infixExpression($assert_num($notnull_bool($eq(prec, 2)) ? prec : prec + 1));
-      if ($notnull_bool($eq(op.kind, 33/*TokenKind.CONDITIONAL*/))) {
+      if ($notnull_bool($eq(op.get$kind(), 33/*TokenKind.CONDITIONAL*/))) {
         this._eat(8/*TokenKind.COLON*/);
         var z = this.infixExpression($assert_num(prec));
         x = new ConditionalExpression(x, y, z, this._makeSpan(x.span.start));
       }
       else {
         x = new BinaryExpression(op, x, y, this._makeSpan(x.span.start));
       }
     }
     else {
       break;
@@ skipping 53 matching lines @@
   }
   return args;
 }
 lang_Parser.prototype.get$arguments = function() {
   return lang_Parser.prototype.arguments.bind(this);
 }
 lang_Parser.prototype.finishPostfixExpression = function(expr) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
-      return this.finishPostfixExpression(new CallExpression(expr, this.arguments(), this._makeSpan(expr.get$span().start)));
+      return this.finishPostfixExpression(new CallExpression(expr, this.arguments(), this._makeSpan($assert_num(expr.get$span().get$start()))));
 
     case 4/*TokenKind.LBRACK*/:
 
       this._eat(4/*TokenKind.LBRACK*/);
       var index = this.expression();
       this._eat(5/*TokenKind.RBRACK*/);
-      return this.finishPostfixExpression(new IndexExpression(expr, index, this._makeSpan(expr.get$span().start)));
+      return this.finishPostfixExpression(new IndexExpression(expr, index, this._makeSpan($assert_num(expr.get$span().get$start()))));
 
     case 14/*TokenKind.DOT*/:
 
       this._eat(14/*TokenKind.DOT*/);
       var name = this.identifier();
-      var ret = new DotExpression(expr, name, this._makeSpan(expr.get$span().start));
+      var ret = new DotExpression(expr, name, this._makeSpan($assert_num(expr.get$span().get$start())));
       return this.finishPostfixExpression(ret);
 
     case 16/*TokenKind.INCR*/:
     case 17/*TokenKind.DECR*/:
 
       var tok = this._lang_next();
-      return new PostfixExpression(expr, tok, this._makeSpan(expr.get$span().start));
+      return new PostfixExpression(expr, tok, this._makeSpan($assert_num(expr.get$span().get$start())));
 
     case 9/*TokenKind.ARROW*/:
     case 6/*TokenKind.LBRACE*/:
 
       if ($notnull_bool(this._inInitializers)) return expr;
       var body = this.functionBody(true);
       return this._makeFunction(expr, body);
 
     default:
 
       if ($notnull_bool(this._peekIdentifier())) {
-        return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan(expr.get$span().start)));
+        return this.finishPostfixExpression(new DeclaredIdentifier(this._makeType(expr), this.identifier(), this._makeSpan($assert_num(expr.get$span().get$start()))));
       }
       else {
         return expr;
       }
 
   }
 }
 lang_Parser.prototype._isBin = function(expr, kind) {
-  return (expr instanceof BinaryExpression) && expr.op.kind == kind;
+  return $notnull_bool((expr instanceof BinaryExpression) && $eq(expr.get$op().get$kind(), kind));
 }
 lang_Parser.prototype._boolTypeRef = function(span) {
   return new TypeReference(span, world.nonNullBool);
 }
 lang_Parser.prototype._intTypeRef = function(span) {
   return new TypeReference(span, world.intType);
 }
 lang_Parser.prototype._doubleTypeRef = function(span) {
   return new TypeReference(span, world.doubleType);
 }
@@ skipping 58 matching lines @@
       return new LiteralExpression(true, this._boolTypeRef(this._makeSpan(start)), 'true', this._makeSpan(start));
 
     case 96/*TokenKind.FALSE*/:
 
       this._eat(96/*TokenKind.FALSE*/);
       return new LiteralExpression(false, this._boolTypeRef(this._makeSpan(start)), 'false', this._makeSpan(start));
 
     case 61/*TokenKind.HEX_INTEGER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(lang_Parser.parseHex(t.get$text().substring(2)), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(lang_Parser.parseHex($assert_String(t.get$text().substring$1(2))), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 60/*TokenKind.INTEGER*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(Math.parseInt(t.get$text()), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(Math.parseInt($assert_String(t.get$text())), this._intTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 62/*TokenKind.DOUBLE*/:
 
       var t = this._lang_next();
-      return new LiteralExpression(Math.parseDouble(t.get$text()), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
+      return new LiteralExpression(Math.parseDouble($assert_String(t.get$text())), this._doubleTypeRef(this._makeSpan(start)), t.get$text(), this._makeSpan(start));
 
     case 58/*TokenKind.STRING*/:
 
       return this.stringLiteralExpr();
 
     case 66/*TokenKind.INCOMPLETE_STRING*/:
 
       return this.stringInterpolation();
 
     case 52/*TokenKind.LT*/:
 
       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())) {
         this._errorExpected('expression');
       }
       return new VarExpression(this.identifier(), this._makeSpan(start));
 
   }
 }
 lang_Parser.prototype.stringInterpolation = function() {
+  var $0;
   var start = this._peekToken.start;
   var lits = [];
   var startQuote = null, endQuote = null;
   while ($notnull_bool(this._peekKind(66/*TokenKind.INCOMPLETE_STRING*/))) {
     var token = this._lang_next();
     var text = token.get$text();
     if ($notnull_bool(startQuote == null)) {
       if ($notnull_bool(isMultilineString($assert_String(text)))) {
         endQuote = text.substring$2(0, 3);
         startQuote = endQuote + '\n';
       }
       else {
         startQuote = endQuote = text.$index(0);
       }
       text = text.substring$2(0, text.length - 1) + endQuote;
     }
     else {
       text = startQuote + text.substring$2(0, text.length - 1) + endQuote;
     }
-    lits.add$1(this.makeStringLiteral($assert_String(text), token.get$span()));
+    lits.add$1(this.makeStringLiteral($assert_String(text), (($0 = token.get$span()) && $0.is$SourceSpan())));
     if ($notnull_bool(this._maybeEat(6/*TokenKind.LBRACE*/))) {
       lits.add$1(this.expression());
       this._eat(7/*TokenKind.RBRACE*/);
     }
     else {
       var id = this.identifier();
-      lits.add$1(new VarExpression(id, id.get$span()));
+      lits.add$1(new VarExpression(id, (($0 = id.get$span()) && $0.is$SourceSpan())));
     }
   }
   var tok = this._lang_next();
-  if ($notnull_bool($ne(tok.kind, 58/*TokenKind.STRING*/))) {
+  if ($notnull_bool($ne(tok.get$kind(), 58/*TokenKind.STRING*/))) {
     this._errorExpected('interpolated string');
   }
   var text = startQuote + tok.get$text();
-  lits.add$1(this.makeStringLiteral($assert_String(text), tok.get$span()));
+  lits.add$1(this.makeStringLiteral($assert_String(text), (($0 = tok.get$span()) && $0.is$SourceSpan())));
   var span = this._makeSpan(start);
   return new LiteralExpression(lits, this._stringTypeRef((span && span.is$SourceSpan())), '\$\$\$', (span && span.is$SourceSpan()));
 }
 lang_Parser.prototype.makeStringLiteral = function(text, span) {
   return new LiteralExpression(text, this._stringTypeRef(span), text, span);
 }
 lang_Parser.prototype.stringLiteralExpr = function() {
+  var $0;
   var token = this._lang_next();
-  return this.makeStringLiteral(token.get$text(), token.get$span());
+  return this.makeStringLiteral($assert_String(token.get$text()), (($0 = token.get$span()) && $0.is$SourceSpan()));
 }
 lang_Parser.prototype.maybeStringLiteral = function() {
   var kind = this._peek();
   if ($notnull_bool($eq(kind, 58/*TokenKind.STRING*/))) {
     return parseStringLiteral(this._lang_next().get$text());
   }
   else if ($notnull_bool($eq(kind, 59/*TokenKind.STRING_PART*/))) {
     this._lang_next();
     this._errorExpected('string literal, but found interpolated string start');
   }
   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 $0;
   var start = this._peekToken.start;
   var args = this.arguments();
   if (!$notnull_bool(this._inInitializers) && ($notnull_bool(this._peekKind(9/*TokenKind.ARROW*/) || this._peekKind(6/*TokenKind.LBRACE*/)))) {
     var body = this.functionBody(true);
     var formals = this._makeFormals(args);
     var func = new FunctionDefinition(null, null, null, formals, null, body, this._makeSpan(start));
-    return new LambdaExpression(func, func.get$span());
+    return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   else {
-    if (args.length == 1) {
+    if ($notnull_bool($eq(args.length, 1))) {
       return new ParenExpression(args.$index(0).get$value(), this._makeSpan(start));
     }
     else {
       this._lang_error('unexpected comma expression');
       return args.$index(0).get$value();
     }
   }
 }
 lang_Parser.prototype._typeAsIdentifier = function(type) {
   return type.get$name();
@@ skipping 71 matching lines @@
   var start = this._peekToken.start;
   var myType = null;
   var name = this._specialIdentifier(includeOperators);
   if (name == null) {
     myType = this.type(0);
     name = this._specialIdentifier(includeOperators);
     if (name == null) {
       if ($notnull_bool(this._peekIdentifier())) {
         name = this.identifier();
       }
-      else if ((myType instanceof NameTypeReference) && myType.names == null) {
+      else if ($notnull_bool((myType instanceof NameTypeReference) && myType.get$names() == null)) {
         name = this._typeAsIdentifier(myType);
         myType = null;
       }
       else {
       }
     }
   }
   return new DeclaredIdentifier(myType, name, this._makeSpan(start));
 }
 lang_Parser._hexDigit = function(c) {
@@ skipping 105 matching lines @@
   }
   return new TypeParameter(name, myType, this._makeSpan(start));
 }
 lang_Parser.prototype.typeParameters = function() {
   this._eat(52/*TokenKind.LT*/);
   var closed = false;
   var ret = [];
   do {
     var tp = this.typeParameter();
     ret.add$1(tp);
-    if ((tp.extendsType instanceof GenericTypeReference) && tp.extendsType.depth == 0) {
+    if ($notnull_bool((tp.get$extendsType() instanceof GenericTypeReference) && $eq(tp.get$extendsType().get$depth(), 0))) {
       closed = true;
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   if (!$notnull_bool(closed)) {
     this._eat(53/*TokenKind.GT*/);
   }
   return ret;
 }
@@ skipping 17 matching lines @@
 }
 lang_Parser.prototype.addTypeArguments = function(baseType, depth) {
   this._eat(52/*TokenKind.LT*/);
   return this._finishTypeArguments(baseType, depth, []);
 }
 lang_Parser.prototype._finishTypeArguments = function(baseType, depth, types) {
   var delta = -1;
   do {
     var myType = this.type(depth + 1);
     types.add$1(myType);
-    if ((myType instanceof GenericTypeReference) && myType.depth <= depth) {
-      delta = depth - myType.depth;
+    if ((myType instanceof GenericTypeReference) && myType.get$depth() <= depth) {
+      delta = depth - $assert_num(myType.get$depth());
       break;
     }
   }
   while ($notnull_bool(this._maybeEat(11/*TokenKind.COMMA*/)))
   if (delta >= 0) {
     depth -= $assert_num(delta);
   }
   else {
     depth = this._eatClosingAngle(depth);
   }
@@ skipping 41 matching lines @@
     names.add$1(this.identifier());
   }
   var typeRef = new NameTypeReference(isFinal, name, names, this._makeSpan(start));
   if ($notnull_bool(this._peekKind(52/*TokenKind.LT*/))) {
     return this.addTypeArguments((typeRef && typeRef.is$TypeReference()), depth);
   }
   else {
     return typeRef;
   }
 }
+lang_Parser.prototype.get$type = function() {
+  return lang_Parser.prototype.type.bind(this);
+}
 lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
+  var $0;
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
-  var type = di.type;
+  var type = di.get$type();
   var name = di.get$name();
   var value = null;
   if ($notnull_bool(this._maybeEat(20/*TokenKind.ASSIGN*/))) {
     if (!$notnull_bool(inOptionalBlock)) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if ($notnull_bool(this._peekKind(2/*TokenKind.LPAREN*/))) {
     var formals = this.formalParameterList();
     var func = new FunctionDefinition(null, type, name, formals, null, null, this._makeSpan(start));
-    type = new FunctionTypeReference(false, func, func.get$span());
+    type = new FunctionTypeReference(false, func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   if ($notnull_bool(inOptionalBlock && value == null)) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
@@ skipping 12 matching lines @@
       formals.add$1(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 $0;
   var tok = this._lang_next();
-  if (!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.kind)))) {
-    this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
+  if (!$notnull_bool(TokenKind.isIdentifier($assert_num(tok.get$kind())))) {
+    this._lang_error(('expected identifier, but found ' + tok + ''), (($0 = tok.get$span()) && $0.is$SourceSpan()));
   }
-  return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
+  return new lang_Identifier(tok.get$text(), this._makeSpan($assert_num(tok.get$start())));
 }
 lang_Parser.prototype._makeFunction = function(expr, body) {
+  var $0;
   var name, type;
   if ((expr instanceof CallExpression)) {
-    if ((expr.target instanceof VarExpression)) {
-      name = expr.target.get$name();
+    if ((expr.get$target() instanceof VarExpression)) {
+      name = expr.get$target().get$name();
       type = null;
     }
-    else if ((expr.target instanceof DeclaredIdentifier)) {
-      name = expr.target.get$name();
-      type = expr.target.type;
+    else if ((expr.get$target() instanceof DeclaredIdentifier)) {
+      name = expr.get$target().get$name();
+      type = expr.get$target().get$type();
     }
     else {
       this._lang_error('bad function');
     }
     var formals = this._makeFormals(expr.get$arguments());
-    var span = new SourceSpan(expr.get$span().file, expr.get$span().start, body.get$span().end);
+    var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
     var func = new FunctionDefinition(null, type, name, formals, null, body, (span && span.is$SourceSpan()));
-    return new LambdaExpression(func, func.get$span());
+    return new LambdaExpression(func, (($0 = func.get$span()) && $0.is$SourceSpan()));
   }
   else {
     this._lang_error('expected function');
   }
 }
 lang_Parser.prototype._makeFormal = function(expr) {
   var $0;
   if ((expr instanceof VarExpression)) {
-    return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
+    return new FormalNode(false, false, null, expr.get$name(), null, (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
   else if ((expr instanceof DeclaredIdentifier)) {
-    return new FormalNode(false, false, expr.type, expr.get$name(), null, expr.get$span());
+    return new FormalNode(false, false, expr.get$type(), expr.get$name(), null, (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
-  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.x instanceof DeclaredIdentifier)))) {
-    var di = (($0 = expr.x) && $0.is$DeclaredIdentifier());
-    return new FormalNode(false, false, di.type, di.name, expr.y, expr.get$span());
+  else if ($notnull_bool(this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.get$x() instanceof DeclaredIdentifier)))) {
+    var di = (($0 = expr.get$x()) && $0.is$DeclaredIdentifier());
+    return new FormalNode(false, false, di.type, di.name, expr.get$y(), (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
   else if ($notnull_bool(this._isBin(expr, 52/*TokenKind.LT*/))) {
     return null;
   }
   else if ((expr instanceof ListExpression)) {
     return this._makeFormalsFromList(expr);
   }
   else {
-    this._lang_error('expected formal', expr.get$span());
+    this._lang_error('expected formal', (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
 }
 lang_Parser.prototype._makeFormalsFromList = function(expr) {
+  var $0;
   if ($notnull_bool(expr.get$isConst())) {
-    this._lang_error('expected formal, but found "const"', expr.get$span());
+    this._lang_error('expected formal, but found "const"', (($0 = expr.get$span()) && $0.is$SourceSpan()));
   }
-  else if ($notnull_bool($ne(expr.type, null))) {
-    this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
+  else if ($notnull_bool($ne(expr.get$type(), null))) {
+    this._lang_error('expected formal, but found generic type arguments', (($0 = expr.get$type().get$span()) && $0.is$SourceSpan()));
   }
-  return this._makeFormalsFromExpressions(expr.values, false);
+  return this._makeFormalsFromExpressions(expr.get$values(), false);
 }
 lang_Parser.prototype._makeFormals = function(arguments) {
   var expressions = [];
   for (var i = 0;
-   i < arguments.length; i++) {
+   i < $assert_num(arguments.length); i++) {
     var arg = arguments.$index(i);
-    if (arg.label != null) {
+    if ($notnull_bool($ne(arg.get$label(), null))) {
       this._lang_error('expected formal, but found ":"');
     }
     expressions.add$1(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
 lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var $0;
   var formals = [];
   for (var i = 0;
-   i < expressions.length; i++) {
+   i < $assert_num(expressions.length); i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if ($notnull_bool(formal == null)) {
-      var baseType = this._makeType(expressions.$index(i).x);
-      var typeParams = [this._makeType(expressions.$index(i).y)];
+      var baseType = this._makeType(expressions.$index(i).get$x());
+      var typeParams = [this._makeType(expressions.$index(i).get$y())];
       i++;
-      while (i < expressions.length) {
+      while (i < $assert_num(expressions.length)) {
         var expr = expressions.$index(i++);
         if ($notnull_bool(this._isBin(expr, 53/*TokenKind.GT*/))) {
-          typeParams.add$1(this._makeType(expr.x));
-          var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
+          typeParams.add$1(this._makeType(expr.get$x()));
+          var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan($assert_num(baseType.get$span().get$start())));
           var name = null;
-          if ((expr.y instanceof VarExpression)) {
-            var ve = (($0 = expr.y) && $0.is$VarExpression());
+          if ((expr.get$y() instanceof VarExpression)) {
+            var ve = (($0 = expr.get$y()) && $0.is$VarExpression());
             name = ve.name;
           }
           else {
-            this._lang_error('expected formal', expr.get$span());
+            this._lang_error('expected formal', (($0 = expr.get$span()) && $0.is$SourceSpan()));
           }
-          formal = new FormalNode(false, false, type, name, null, this._makeSpan(expressions.$index(0).get$span().start));
+          formal = new FormalNode(false, false, type, name, null, this._makeSpan($assert_num(expressions.$index(0).get$span().get$start())));
           break;
         }
         else {
           typeParams.add$1(this._makeType(expr));
         }
       }
       formals.add$1(formal);
     }
     else if (!!(formal && formal.is$List)) {
       formals.addAll$1(formal);
       if (!$notnull_bool(allowOptional)) {
-        this._lang_error('unexpected nested optional formal', expressions.$index(i).get$span());
+        this._lang_error('unexpected nested optional formal', (($0 = expressions.$index(i).get$span()) && $0.is$SourceSpan()));
       }
     }
     else {
       formals.add$1(formal);
     }
   }
   return formals;
 }
 lang_Parser.prototype._makeDeclaredIdentifier = function(e) {
+  var $0;
   if ((e instanceof VarExpression)) {
-    return new DeclaredIdentifier(null, e.get$name(), e.get$span());
+    return new DeclaredIdentifier(null, e.get$name(), (($0 = e.get$span()) && $0.is$SourceSpan()));
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
     this._lang_error('expected declared identifier');
-    return new DeclaredIdentifier(null, null, e.get$span());
+    return new DeclaredIdentifier(null, null, (($0 = e.get$span()) && $0.is$SourceSpan()));
   }
 }
 lang_Parser.prototype._makeLabel = function(expr) {
   if ((expr instanceof VarExpression)) {
     return expr.get$name();
   }
   else {
     this._errorExpected('label');
     return null;
   }
@@ skipping 52 matching lines @@
 $inherits(lang_Expression, lang_Node);
 lang_Expression.prototype.is$lang_Expression = function(){return this;};
 // ********** Code for TypeReference **************
 function TypeReference(span, type) {
   this.type = type;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(TypeReference, lang_Node);
 TypeReference.prototype.is$TypeReference = function(){return this;};
+TypeReference.prototype.get$type = function() { return this.type; };
+TypeReference.prototype.set$type = function(value) { return this.type = value; };
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 TypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DirectiveDefinition **************
 function DirectiveDefinition(name, arguments, span) {
   this.name = name;
   this.arguments = arguments;
@@ skipping 27 matching lines @@
 $inherits(TypeDefinition, Definition);
 TypeDefinition.prototype.is$TypeDefinition = function(){return this;};
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 TypeDefinition.prototype.set$isClass = function(value) { return this.isClass = value; };
 TypeDefinition.prototype.get$name = function() { return this.name; };
 TypeDefinition.prototype.set$name = function(value) { return this.name = value; };
 TypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 TypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 TypeDefinition.prototype.get$nativeType = function() { return this.nativeType; };
 TypeDefinition.prototype.set$nativeType = function(value) { return this.nativeType = value; };
+TypeDefinition.prototype.get$body = function() { return this.body; };
+TypeDefinition.prototype.set$body = function(value) { return this.body = value; };
 TypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 TypeDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionTypeDefinition **************
 function FunctionTypeDefinition(func, typeParameters, span) {
   this.func = func;
   this.typeParameters = typeParameters;
   Definition.call(this, span);
   // Initializers done
 }
 $inherits(FunctionTypeDefinition, Definition);
+FunctionTypeDefinition.prototype.get$func = function() { return this.func; };
+FunctionTypeDefinition.prototype.set$func = function(value) { return this.func = value; };
 FunctionTypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 FunctionTypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionTypeDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeDefinition(this);
 }
 FunctionTypeDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for VariableDefinition **************
 function VariableDefinition(modifiers, type, names, values, span) {
   this.modifiers = modifiers;
   this.type = type;
   this.names = names;
   this.values = values;
   Definition.call(this, span);
   // Initializers done
 }
 $inherits(VariableDefinition, Definition);
+VariableDefinition.prototype.get$type = function() { return this.type; };
+VariableDefinition.prototype.set$type = function(value) { return this.type = value; };
+VariableDefinition.prototype.get$names = function() { return this.names; };
+VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
+VariableDefinition.prototype.get$values = function() { return this.values; };
+VariableDefinition.prototype.set$values = function(value) { return this.values = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 VariableDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionDefinition **************
 function FunctionDefinition(modifiers, returnType, name, formals, initializers, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
   this.initializers = initializers;
   this.body = body;
   Definition.call(this, span);
   // Initializers done
 }
 $inherits(FunctionDefinition, Definition);
 FunctionDefinition.prototype.is$FunctionDefinition = function(){return this;};
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
+FunctionDefinition.prototype.get$initializers = function() { return this.initializers; };
+FunctionDefinition.prototype.set$initializers = function(value) { return this.initializers = value; };
+FunctionDefinition.prototype.get$body = function() { return this.body; };
+FunctionDefinition.prototype.set$body = function(value) { return this.body = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 FunctionDefinition.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ReturnStatement **************
 function ReturnStatement(value, span) {
   this.value = value;
   lang_Statement.call(this, span);
@@ skipping 36 matching lines @@
 AssertStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BreakStatement **************
 function BreakStatement(label, span) {
   this.label = label;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(BreakStatement, lang_Statement);
+BreakStatement.prototype.get$label = function() { return this.label; };
+BreakStatement.prototype.set$label = function(value) { return this.label = value; };
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 BreakStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ContinueStatement **************
 function ContinueStatement(label, span) {
   this.label = label;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(ContinueStatement, lang_Statement);
+ContinueStatement.prototype.get$label = function() { return this.label; };
+ContinueStatement.prototype.set$label = function(value) { return this.label = value; };
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 ContinueStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for IfStatement **************
 function IfStatement(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(IfStatement, lang_Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 IfStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for WhileStatement **************
 function WhileStatement(test, body, span) {
   this.test = test;
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(WhileStatement, lang_Statement);
+WhileStatement.prototype.get$body = function() { return this.body; };
+WhileStatement.prototype.set$body = function(value) { return this.body = value; };
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 WhileStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DoStatement **************
 function DoStatement(body, test, span) {
   this.body = body;
   this.test = test;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(DoStatement, lang_Statement);
+DoStatement.prototype.get$body = function() { return this.body; };
+DoStatement.prototype.set$body = function(value) { return this.body = value; };
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 DoStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ForStatement **************
 function ForStatement(init, test, step, body, span) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(ForStatement, lang_Statement);
+ForStatement.prototype.get$body = function() { return this.body; };
+ForStatement.prototype.set$body = function(value) { return this.body = value; };
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 ForStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ForInStatement **************
 function ForInStatement(item, list, body, span) {
   this.item = item;
   this.list = list;
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(ForInStatement, lang_Statement);
+ForInStatement.prototype.get$body = function() { return this.body; };
+ForInStatement.prototype.set$body = function(value) { return this.body = value; };
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 ForInStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for TryStatement **************
 function TryStatement(body, catches, finallyBlock, span) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(TryStatement, lang_Statement);
+TryStatement.prototype.get$body = function() { return this.body; };
+TryStatement.prototype.set$body = function(value) { return this.body = value; };
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 TryStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for SwitchStatement **************
 function SwitchStatement(test, cases, span) {
   this.test = test;
   this.cases = cases;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(SwitchStatement, lang_Statement);
+SwitchStatement.prototype.get$cases = function() { return this.cases; };
+SwitchStatement.prototype.set$cases = function(value) { return this.cases = value; };
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 SwitchStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BlockStatement **************
 function BlockStatement(body, span) {
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(BlockStatement, lang_Statement);
 BlockStatement.prototype.is$BlockStatement = function(){return this;};
+BlockStatement.prototype.get$body = function() { return this.body; };
+BlockStatement.prototype.set$body = function(value) { return this.body = value; };
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 BlockStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for LabeledStatement **************
 function LabeledStatement(name, body, span) {
   this.name = name;
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(LabeledStatement, lang_Statement);
 LabeledStatement.prototype.get$name = function() { return this.name; };
 LabeledStatement.prototype.set$name = function(value) { return this.name = value; };
+LabeledStatement.prototype.get$body = function() { return this.body; };
+LabeledStatement.prototype.set$body = function(value) { return this.body = value; };
 LabeledStatement.prototype.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
 LabeledStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_ExpressionStatement **************
 function lang_ExpressionStatement(body, span) {
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(lang_ExpressionStatement, lang_Statement);
+lang_ExpressionStatement.prototype.get$body = function() { return this.body; };
+lang_ExpressionStatement.prototype.set$body = function(value) { return this.body = value; };
 lang_ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 lang_ExpressionStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for EmptyStatement **************
 function EmptyStatement(span) {
   lang_Statement.call(this, span);
   // Initializers done
@@ skipping 17 matching lines @@
 DietStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for NativeStatement **************
 function NativeStatement(body, span) {
   this.body = body;
   lang_Statement.call(this, span);
   // Initializers done
 }
 $inherits(NativeStatement, lang_Statement);
+NativeStatement.prototype.get$body = function() { return this.body; };
+NativeStatement.prototype.set$body = function(value) { return this.body = value; };
 NativeStatement.prototype.visit = function(visitor) {
   return visitor.visitNativeStatement(this);
 }
 NativeStatement.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for LambdaExpression **************
 function LambdaExpression(func, span) {
   this.func = func;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(LambdaExpression, lang_Expression);
 LambdaExpression.prototype.is$LambdaExpression = function(){return this;};
+LambdaExpression.prototype.get$func = function() { return this.func; };
+LambdaExpression.prototype.set$func = function(value) { return this.func = value; };
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 LambdaExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CallExpression **************
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(CallExpression, lang_Expression);
 CallExpression.prototype.is$CallExpression = function(){return this;};
+CallExpression.prototype.get$target = function() { return this.target; };
+CallExpression.prototype.set$target = function(value) { return this.target = value; };
 CallExpression.prototype.get$arguments = function() { return this.arguments; };
 CallExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 CallExpression.prototype.visit = function(visitor) {
   return visitor.visitCallExpression(this);
 }
 CallExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for IndexExpression **************
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(IndexExpression, lang_Expression);
 IndexExpression.prototype.is$IndexExpression = function(){return this;};
+IndexExpression.prototype.get$target = function() { return this.target; };
+IndexExpression.prototype.set$target = function(value) { return this.target = value; };
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 IndexExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for BinaryExpression **************
 function BinaryExpression(op, x, y, span) {
   this.op = op;
   this.x = x;
   this.y = y;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(BinaryExpression, lang_Expression);
 BinaryExpression.prototype.is$BinaryExpression = function(){return this;};
+BinaryExpression.prototype.get$op = function() { return this.op; };
+BinaryExpression.prototype.set$op = function(value) { return this.op = value; };
+BinaryExpression.prototype.get$x = function() { return this.x; };
+BinaryExpression.prototype.set$x = function(value) { return this.x = value; };
+BinaryExpression.prototype.get$y = function() { return this.y; };
+BinaryExpression.prototype.set$y = function(value) { return this.y = value; };
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 BinaryExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for UnaryExpression **************
 function UnaryExpression(op, self, span) {
   this.op = op;
   this.self = self;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(UnaryExpression, lang_Expression);
+UnaryExpression.prototype.get$op = function() { return this.op; };
+UnaryExpression.prototype.set$op = function(value) { return this.op = value; };
+UnaryExpression.prototype.get$self = function() { return this.self; };
+UnaryExpression.prototype.set$self = function(value) { return this.self = value; };
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 UnaryExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for PostfixExpression **************
 function PostfixExpression(body, op, span) {
   this.body = body;
   this.op = op;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(PostfixExpression, lang_Expression);
 PostfixExpression.prototype.is$PostfixExpression = function(){return this;};
+PostfixExpression.prototype.get$body = function() { return this.body; };
+PostfixExpression.prototype.set$body = function(value) { return this.body = value; };
+PostfixExpression.prototype.get$op = function() { return this.op; };
+PostfixExpression.prototype.set$op = function(value) { return this.op = value; };
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 PostfixExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_NewExpression **************
 function lang_NewExpression(isConst, type, name, arguments, span) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(lang_NewExpression, lang_Expression);
 lang_NewExpression.prototype.get$isConst = function() { return this.isConst; };
 lang_NewExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
+lang_NewExpression.prototype.get$type = function() { return this.type; };
+lang_NewExpression.prototype.set$type = function(value) { return this.type = value; };
 lang_NewExpression.prototype.get$name = function() { return this.name; };
 lang_NewExpression.prototype.set$name = function(value) { return this.name = value; };
 lang_NewExpression.prototype.get$arguments = function() { return this.arguments; };
 lang_NewExpression.prototype.set$arguments = function(value) { return this.arguments = value; };
 lang_NewExpression.prototype.visit = function(visitor) {
   return visitor.visitNewExpression(this);
 }
 lang_NewExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ListExpression **************
 function ListExpression(isConst, type, values, span) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(ListExpression, lang_Expression);
 ListExpression.prototype.get$isConst = function() { return this.isConst; };
 ListExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
+ListExpression.prototype.get$type = function() { return this.type; };
+ListExpression.prototype.set$type = function(value) { return this.type = value; };
+ListExpression.prototype.get$values = function() { return this.values; };
+ListExpression.prototype.set$values = function(value) { return this.values = value; };
 ListExpression.prototype.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 ListExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for MapExpression **************
 function MapExpression(isConst, type, items, span) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(MapExpression, lang_Expression);
 MapExpression.prototype.get$isConst = function() { return this.isConst; };
 MapExpression.prototype.set$isConst = function(value) { return this.isConst = value; };
+MapExpression.prototype.get$type = function() { return this.type; };
+MapExpression.prototype.set$type = function(value) { return this.type = value; };
 MapExpression.prototype.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 MapExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ConditionalExpression **************
 function ConditionalExpression(test, trueBranch, falseBranch, span) {
   this.test = test;
   this.trueBranch = trueBranch;
@@ skipping 10 matching lines @@
 };
 // ********** Code for IsExpression **************
 function IsExpression(isTrue, x, type, span) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(IsExpression, lang_Expression);
+IsExpression.prototype.get$x = function() { return this.x; };
+IsExpression.prototype.set$x = function(value) { return this.x = value; };
+IsExpression.prototype.get$type = function() { return this.type; };
+IsExpression.prototype.set$type = function(value) { return this.type = value; };
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 IsExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ParenExpression **************
 function ParenExpression(body, span) {
   this.body = body;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(ParenExpression, lang_Expression);
+ParenExpression.prototype.get$body = function() { return this.body; };
+ParenExpression.prototype.set$body = function(value) { return this.body = value; };
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 ParenExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for DotExpression **************
 function DotExpression(self, name, span) {
   this.self = self;
   this.name = name;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(DotExpression, lang_Expression);
 DotExpression.prototype.is$DotExpression = function(){return this;};
+DotExpression.prototype.get$self = function() { return this.self; };
+DotExpression.prototype.set$self = function(value) { return this.self = value; };
 DotExpression.prototype.get$name = function() { return this.name; };
 DotExpression.prototype.set$name = function(value) { return this.name = value; };
 DotExpression.prototype.visit = function(visitor) {
   return visitor.visitDotExpression(this);
 }
 DotExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for VarExpression **************
 function VarExpression(name, span) {
@@ skipping 51 matching lines @@
 function LiteralExpression(value, type, text, span) {
   this.value = value;
   this.type = type;
   this.text = text;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(LiteralExpression, lang_Expression);
 LiteralExpression.prototype.get$value = function() { return this.value; };
 LiteralExpression.prototype.set$value = function(value) { return this.value = value; };
+LiteralExpression.prototype.get$type = function() { return this.type; };
+LiteralExpression.prototype.set$type = function(value) { return this.type = value; };
 LiteralExpression.prototype.get$text = function() { return this.text; };
 LiteralExpression.prototype.set$text = function(value) { return this.text = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 LiteralExpression.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for NameTypeReference **************
 function NameTypeReference(isFinal, name, names, span) {
   this.isFinal = isFinal;
   this.name = name;
   this.names = names;
   TypeReference.call(this, span);
   // Initializers done
 }
 $inherits(NameTypeReference, TypeReference);
 NameTypeReference.prototype.is$NameTypeReference = function(){return this;};
+NameTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
+NameTypeReference.prototype.set$isFinal = function(value) { return this.isFinal = value; };
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
+NameTypeReference.prototype.get$names = function() { return this.names; };
+NameTypeReference.prototype.set$names = function(value) { return this.names = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 NameTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for GenericTypeReference **************
 function GenericTypeReference(baseType, typeArguments, depth, span) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
   TypeReference.call(this, span);
   // Initializers done
 }
 $inherits(GenericTypeReference, TypeReference);
 GenericTypeReference.prototype.is$GenericTypeReference = function(){return this;};
+GenericTypeReference.prototype.get$depth = function() { return this.depth; };
+GenericTypeReference.prototype.set$depth = function(value) { return this.depth = value; };
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 GenericTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FunctionTypeReference **************
 function FunctionTypeReference(isFinal, func, span) {
   this.isFinal = isFinal;
   this.func = func;
   TypeReference.call(this, span);
   // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.is$FunctionTypeReference = function(){return this;};
+FunctionTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
+FunctionTypeReference.prototype.set$isFinal = function(value) { return this.isFinal = value; };
+FunctionTypeReference.prototype.get$func = function() { return this.func; };
+FunctionTypeReference.prototype.set$func = function(value) { return this.func = value; };
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 FunctionTypeReference.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for ArgumentNode **************
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(ArgumentNode, lang_Node);
 ArgumentNode.prototype.is$ArgumentNode = function(){return this;};
+ArgumentNode.prototype.get$label = function() { return this.label; };
+ArgumentNode.prototype.set$label = function(value) { return this.label = value; };
 ArgumentNode.prototype.get$value = function() { return this.value; };
 ArgumentNode.prototype.set$value = function(value) { return this.value = value; };
 ArgumentNode.prototype.visit = function(visitor) {
   return visitor.visitArgumentNode(this);
 }
 ArgumentNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for FormalNode **************
 function FormalNode(isThis, isRest, type, name, value, span) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
   this.name = name;
   this.value = value;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(FormalNode, lang_Node);
+FormalNode.prototype.get$type = function() { return this.type; };
+FormalNode.prototype.set$type = function(value) { return this.type = value; };
 FormalNode.prototype.get$name = function() { return this.name; };
 FormalNode.prototype.set$name = function(value) { return this.name = value; };
 FormalNode.prototype.get$value = function() { return this.value; };
 FormalNode.prototype.set$value = function(value) { return this.value = value; };
 FormalNode.prototype.visit = function(visitor) {
   return visitor.visitFormalNode(this);
 }
 FormalNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CatchNode **************
 function CatchNode(exception, trace, body, span) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(CatchNode, lang_Node);
 CatchNode.prototype.get$exception = function() { return this.exception; };
 CatchNode.prototype.set$exception = function(value) { return this.exception = value; };
+CatchNode.prototype.get$trace = function() { return this.trace; };
+CatchNode.prototype.set$trace = function(value) { return this.trace = value; };
+CatchNode.prototype.get$body = function() { return this.body; };
+CatchNode.prototype.set$body = function(value) { return this.body = value; };
 CatchNode.prototype.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 CatchNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for CaseNode **************
 function CaseNode(label, cases, statements, span) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(CaseNode, lang_Node);
+CaseNode.prototype.get$label = function() { return this.label; };
+CaseNode.prototype.set$label = function(value) { return this.label = value; };
+CaseNode.prototype.get$cases = function() { return this.cases; };
+CaseNode.prototype.set$cases = function(value) { return this.cases = value; };
+CaseNode.prototype.get$statements = function() { return this.statements; };
+CaseNode.prototype.set$statements = function(value) { return this.statements = value; };
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 CaseNode.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for TypeParameter **************
 function TypeParameter(name, extendsType, span) {
   this.name = name;
   this.extendsType = extendsType;
   lang_Node.call(this, span);
   // Initializers done
 }
 $inherits(TypeParameter, lang_Node);
 TypeParameter.prototype.get$name = function() { return this.name; };
 TypeParameter.prototype.set$name = function(value) { return this.name = value; };
+TypeParameter.prototype.get$extendsType = function() { return this.extendsType; };
+TypeParameter.prototype.set$extendsType = function(value) { return this.extendsType = value; };
 TypeParameter.prototype.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
 TypeParameter.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_Identifier **************
 function lang_Identifier(name, span) {
   this.name = name;
   lang_Node.call(this, span);
@@ skipping 10 matching lines @@
 };
 // ********** Code for DeclaredIdentifier **************
 function DeclaredIdentifier(type, name, span) {
   this.type = type;
   this.name = name;
   lang_Expression.call(this, span);
   // Initializers done
 }
 $inherits(DeclaredIdentifier, lang_Expression);
 DeclaredIdentifier.prototype.is$DeclaredIdentifier = function(){return this;};
+DeclaredIdentifier.prototype.get$type = function() { return this.type; };
+DeclaredIdentifier.prototype.set$type = function(value) { return this.type = value; };
 DeclaredIdentifier.prototype.get$name = function() { return this.name; };
 DeclaredIdentifier.prototype.set$name = function(value) { return this.name = value; };
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 DeclaredIdentifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_Type **************
 function lang_Type(name) {
   this.name = name;
   this.isTested = false;
   // Initializers done
 }
 lang_Type.prototype.is$lang_Type = function(){return this;};
 lang_Type.prototype.is$Named = function(){return this;};
 lang_Type.prototype.get$name = function() { return this.name; };
+lang_Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
+lang_Type.prototype.set$typeCheckCode = function(value) { return this.typeCheckCode = value; };
+lang_Type.prototype.get$varStubs = function() { return this.varStubs; };
+lang_Type.prototype.set$varStubs = function(value) { return this.varStubs = value; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
   var $0;
   if (this._typeMember == null) {
     this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
   return (($0 = this._typeMember) && $0.is$TypeMember());
 }
@@ skipping 145 matching lines @@
   }
   if ($eq(this, other)) return true;
   if ($notnull_bool(this.get$isVar())) return true;
   if ($notnull_bool(other.get$isVar())) return true;
   if ($notnull_bool(other._isDirectSupertypeOf(this))) return true;
   var call = this.getCallMethod();
   var otherCall = other.getCallMethod();
   if ($notnull_bool($ne(call, null) && $ne(otherCall, null))) {
     return lang_Type._isFunctionSubtypeOf((call && call.is$MethodMember()), (otherCall && otherCall.is$MethodMember()));
   }
-  if ($notnull_bool($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null)) && $ne(other.get$typeArgsInOrder(), null)) && this.get$typeArgsInOrder().length == other.get$typeArgsInOrder().length) {
+  if ($notnull_bool($notnull_bool($notnull_bool($eq(this.get$genericType(), other.get$genericType()) && $ne(this.get$typeArgsInOrder(), null)) && $ne(other.get$typeArgsInOrder(), null)) && $eq(this.get$typeArgsInOrder().length, other.get$typeArgsInOrder().length))) {
     var t = this.get$typeArgsInOrder().iterator$0();
     var s = other.get$typeArgsInOrder().iterator$0();
     while ($notnull_bool(t.hasNext$0())) {
       if (!$notnull_bool(t.next$0().isSubtypeOf$1(s.next$0()))) return false;
     }
     return true;
   }
   if ($notnull_bool(this.get$parent() != null && this.get$parent().isSubtypeOf(other))) {
     return true;
   }
   if (this.get$interfaces() != null && this.get$interfaces().some((function (i) {
     return i.isSubtypeOf$1(other);
   })
   )) {
     return true;
   }
   return false;
 }
 lang_Type._isFunctionSubtypeOf = function(t, s) {
   if (!$notnull_bool(s.returnType.get$isVoid()) && !$notnull_bool(s.returnType.isAssignable(t.returnType))) {
     return false;
   }
   var tp = t.parameters;
   var sp = s.parameters;
-  if (tp.length < sp.length) return false;
+  if (tp.length < $assert_num(sp.length)) return false;
   for (var i = 0;
-   i < sp.length; i++) {
-    if ($ne(tp.$index(i).get$isOptional(), sp.$index(i).get$isOptional())) return false;
+   i < $assert_num(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$1(sp.$index(i).type))) return false;
+    if (!$notnull_bool(tp.$index(i).get$type().isAssignable$1(sp.$index(i).get$type()))) return false;
   }
-  if (tp.length > sp.length && !$notnull_bool(tp.$index(sp.length).get$isOptional())) return false;
+  if (tp.length > $assert_num(sp.length) && !$notnull_bool(tp.$index(sp.length).get$isOptional())) return false;
   return true;
 }
 lang_Type.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 lang_Type.prototype.ensureSubtypeOf$3 = function($0, $1, $2) {
   return this.ensureSubtypeOf(($0 && $0.is$lang_Type()), ($1 && $1.is$SourceSpan()), $assert_bool($2));
 };
 lang_Type.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
@@ skipping 26 matching lines @@
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for ParameterType **************
 function ParameterType(name, typeParameter) {
   this.typeParameter = typeParameter;
   lang_Type.call(this, name);
   // Initializers done
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.is$ParameterType = function(){return this;};
+ParameterType.prototype.get$extendsType = function() { return this.extendsType; };
+ParameterType.prototype.set$extendsType = function(value) { return this.extendsType = value; };
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
   return this.typeParameter.span;
 }
 ParameterType.prototype.get$constructors = function() {
@@ skipping 53 matching lines @@
 ParameterType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for NonNullableType **************
 function NonNullableType(type) {
   this.type = type;
   lang_Type.call(this, type.name);
   // Initializers done
 }
 $inherits(NonNullableType, lang_Type);
+NonNullableType.prototype.get$type = function() { return this.type; };
 NonNullableType.prototype.get$isNullable = function() {
   return false;
 }
 NonNullableType.prototype.get$isBool = function() {
   return this.type.get$isBool();
 }
 NonNullableType.prototype.get$isUsed = function() {
   return false;
 }
 NonNullableType.prototype.isSubtypeOf = function(other) {
@@ skipping 138 matching lines @@
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.isClass;
 }
 ConcreteType.prototype.get$library = function() {
   return this.genericType.library;
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
-  return this.typeArguments.getValues().some$1((function (e) {
+  return $assert_bool(this.typeArguments.getValues().some$1((function (e) {
     return (e instanceof ParameterType);
   })
-  );
+  ));
 }
 ConcreteType.prototype.get$members = function() { return this.members; };
 ConcreteType.prototype.set$members = function(value) { return this.members = value; };
 ConcreteType.prototype.get$constructors = function() { return this.constructors; };
 ConcreteType.prototype.set$constructors = function(value) { return this.constructors = value; };
 ConcreteType.prototype.get$factories = function() { return this.factories; };
 ConcreteType.prototype.set$factories = function(value) { return this.factories = value; };
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   var newTypeArgs = [];
   var needsNewType = false;
@@ skipping 23 matching lines @@
     }
   }
   return this._interfaces;
 }
 ConcreteType.prototype.getCallMethod = function() {
   return this.genericType.getCallMethod();
 }
 ConcreteType.prototype.getAllMembers = function() {
   var result = this.genericType.getAllMembers();
   var $list = result.getKeys$0();
-  for (var $i = result.getKeys$0().iterator(); $i.hasNext$0(); ) {
+  for (var $i = result.getKeys$0().iterator$0(); $i.hasNext$0(); ) {
     var memberName = $i.next$0();
     var myMember = this.members.$index(memberName);
     if ($notnull_bool($ne(myMember, null))) {
       result.$setindex(memberName, myMember);
     }
   }
   return (result && result.is$Map$String$Member());
 }
 ConcreteType.prototype.markUsed = function() {
   this.genericType.markUsed();
 }
 ConcreteType.prototype.genMethod = function(method) {
   this.genericType.genMethod(method);
 }
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
 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 ($ne(genericMember.declaringType, this.genericType)) {
-    if (!$notnull_bool(genericMember.declaringType.get$isGeneric())) return genericMember;
-    var newDeclaringType = genericMember.declaringType.getOrMakeConcreteType(this.typeArgsInOrder);
+  if ($notnull_bool($ne(genericMember.get$declaringType(), this.genericType))) {
+    if (!$notnull_bool(genericMember.get$declaringType().get$isGeneric())) return genericMember;
+    var newDeclaringType = genericMember.get$declaringType().getOrMakeConcreteType$1(this.typeArgsInOrder);
     var factory = newDeclaringType.getFactory$2(this.genericType, constructorName);
     if (factory != null) return factory;
     return newDeclaringType.getConstructor$1(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);
@@ skipping 184 matching lines @@
 DefinedType.prototype.genMethod = function(method) {
   if ($notnull_bool(this.isUsed)) {
     world.gen.genMethod(method);
   }
   else if ($notnull_bool(this.isClass)) {
     if (this._lazyGenMethods == null) this._lazyGenMethods = $map([]);
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
+  var $0;
   if (types == null) return [];
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed() && !($notnull_bool(this.library.get$isCore() || this.library.get$isCoreImpl())))) {
-      world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
+      world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', (($0 = type.get$span()) && $0.is$SourceSpan()));
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
   $assert(this._subtypes == null, "_subtypes == null", "type.dart", 746, 12);
   this.directSubtypes.add(type);
 }
@@ skipping 52 matching lines @@
   return -1;
 }
 DefinedType.prototype.resolve = function() {
   var $this = this; // closure support
   var $0;
   if ((this.definition instanceof TypeDefinition)) {
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     if ($notnull_bool(this.isClass)) {
       if (typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0) {
         if (typeDef.extendsTypes.length > 1) {
-          world.error('more than one base class', typeDef.extendsTypes.$index(1).get$span());
+          world.error('more than one base class', (($0 = typeDef.extendsTypes.$index(1).get$span()) && $0.is$SourceSpan()));
         }
         var extendsTypeRef = typeDef.extendsTypes.$index(0);
         if ((extendsTypeRef instanceof GenericTypeReference)) {
           var g = (extendsTypeRef && extendsTypeRef.is$GenericTypeReference());
           this.set$parent(this.resolveType(g.baseType, true));
         }
         this.set$parent(this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true));
         if (!$notnull_bool(this.get$parent().get$isClass())) {
-          world.error('class may not extend an interface - use implements', typeDef.extendsTypes.$index(0).get$span());
+          world.error('class may not extend an interface - use implements', (($0 = typeDef.extendsTypes.$index(0).get$span()) && $0.is$SourceSpan()));
         }
         this.get$parent().addDirectSubtype(this);
         if ($notnull_bool(this._cycleInClassExtends())) {
-          world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
+          world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), (($0 = extendsTypeRef.get$span()) && $0.is$SourceSpan()));
         }
       }
       else {
         if (!$notnull_bool(this.get$isObject())) {
           this.set$parent(world.objectType);
           this.get$parent().addDirectSubtype(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if (typeDef.factoryType != null) {
         world.error('factory not allowed on classes', typeDef.factoryType.span);
       }
     }
     else {
       if (typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0) {
-        world.error('implements not allowed on interfaces (use extends)', typeDef.implementsTypes.$index(0).get$span());
+        world.error('implements not allowed on interfaces (use extends)', (($0 = typeDef.implementsTypes.$index(0).get$span()) && $0.is$SourceSpan()));
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
       if (res >= 0) {
-        world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), typeDef.extendsTypes.$index(res).get$span());
+        world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), (($0 = typeDef.extendsTypes.$index(res).get$span()) && $0.is$SourceSpan()));
       }
       if (typeDef.factoryType != null) {
         this.factory_ = this.resolveType(typeDef.factoryType, true);
         if (this.factory_ == null) {
           world.warning('unresolved factory', typeDef.factoryType.span);
         }
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
@@ skipping 26 matching lines @@
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if ($notnull_bool(method.get$isConstructor())) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1 && $eq(definition.modifiers.$index(0).kind, 75/*TokenKind.FACTORY*/))) {
-    if (this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null) {
+  if ($notnull_bool(definition.modifiers != null && definition.modifiers.length == 1 && $eq(definition.modifiers.$index(0).get$kind(), 75/*TokenKind.FACTORY*/))) {
+    if (this.factories.getFactory($assert_String(method.get$constructorName()), $assert_String(method.get$name())) != null) {
       world.error(('duplicate factory definition of "' + method.get$name() + '"'), definition.span);
       return;
     }
-    this.factories.addFactory(method.get$constructorName(), $assert_String(method.get$name()), (method && method.is$Member()));
+    this.factories.addFactory($assert_String(method.get$constructorName()), $assert_String(method.get$name()), (method && method.is$Member()));
     return;
   }
   if (methodName.startsWith('get\$') || methodName.startsWith('set\$')) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
     if ($notnull_bool(prop == null)) {
       prop = new PropertyMember($assert_String(propName), this);
       this.members.$setindex(propName, prop);
     }
     if (!(prop instanceof PropertyMember)) {
       world.error(('property conflicts with field "' + propName + '"'), definition.span);
       return;
     }
     if (methodName[0] == 'g') {
-      if (prop.getter != null) {
+      if ($notnull_bool($ne(prop.get$getter(), null))) {
         world.error(('duplicate getter definition for "' + propName + '"'), definition.span);
       }
-      prop.getter = (method && method.is$MethodMember());
+      prop.set$getter(method);
     }
     else {
-      if (prop.setter != null) {
+      if ($notnull_bool($ne(prop.get$setter(), null))) {
         world.error(('duplicate setter definition for "' + propName + '"'), definition.span);
       }
-      prop.setter = (method && method.is$MethodMember());
+      prop.set$setter(method);
     }
     return;
   }
   if (this.members.containsKey(methodName)) {
     world.error(('duplicate method definition of "' + method.get$name() + '"'), definition.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition) {
   for (var i = 0;
    i < definition.names.length; i++) {
     var name = definition.names.$index(i).get$name();
     if (this.members.containsKey(name)) {
       world.error(('duplicate field definition of "' + name + '"'), definition.span);
       return;
     }
     var value = null;
     if (definition.values != null) {
       value = definition.values.$index(i);
     }
     var field = new FieldMember($assert_String(name), this, definition, value);
     this.members.$setindex(name, field);
     if ($notnull_bool(this.isNativeType)) {
-      field.isNative = true;
+      field.set$isNative(true);
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
   ret = this.constructors.$index(constructorName);
   if ($notnull_bool($ne(ret, null))) return ret;
@@ skipping 40 matching lines @@
     if ($notnull_bool($ne(parentMember, null))) {
       if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
         member.override(parentMember);
       }
     }
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
-      return libType.get$typeMember();
+      return (($0 = libType.get$typeMember()) && $0.is$Member());
     }
   }
   return this.getMemberInParents(memberName);
 }
 DefinedType.prototype.getMemberInParents = function(memberName) {
   if ($notnull_bool(this.isClass)) {
     if (this.get$parent() != null) {
       return this.get$parent().getMember(memberName);
     }
     else if ($notnull_bool(this.get$isObject())) {
@@ skipping 121 matching lines @@
       world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
       world.error('wrong number of type arguments', typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
      i < typeRef.typeArguments.length; i++) {
-      var extendsType = baseType.get$typeParameters().$index(i).extendsType;
+      var extendsType = baseType.get$typeParameters().$index(i).get$extendsType();
       var typeArg = this.resolveType((($0 = typeRef.typeArguments.$index(i)) && $0.is$TypeReference()), typeErrors);
       typeArgs.add$1(typeArg);
       if ($notnull_bool($ne(extendsType, null) && !(typeArg instanceof ParameterType))) {
         typeArg.ensureSubtypeOf$3(extendsType, typeRef.typeArguments.$index(i).get$span(), typeErrors);
       }
     }
-    typeRef.type = baseType.getOrMakeConcreteType$1(typeArgs);
+    typeRef.type = (($0 = baseType.getOrMakeConcreteType$1(typeArgs)) && $0.is$lang_Type());
   }
   else if ((node instanceof FunctionTypeReference)) {
     var typeRef = (node && node.is$FunctionTypeReference());
     var name = '';
     if (typeRef.func.name != null) name = typeRef.func.name.name;
     typeRef.type = this.library.getOrAddFunctionType($assert_String(name), typeRef.func, this);
   }
   else {
     world.internalError('unknown type reference', node.span);
   }
@@ skipping 84 matching lines @@
 FixedCollection.prototype.filter = function(f) {
   return Collections.filter(this, new ListFactory(), f);
 }
 FixedCollection.prototype.some = function(f) {
   return Collections.some(this, f);
 }
 FixedCollection.prototype.isEmpty = function() {
   return this.length == 0;
 }
 FixedCollection.prototype.filter$1 = FixedCollection.prototype.filter;
+FixedCollection.prototype.forEach$1 = FixedCollection.prototype.forEach;
 FixedCollection.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 FixedCollection.prototype.iterator$0 = function() {
   return this.iterator();
 };
 FixedCollection.prototype.some$1 = FixedCollection.prototype.some;
 // ********** Code for FixedCollection$Type **************
 function FixedCollection$Type(value, length) {
   this.value = value;
@@ skipping 41 matching lines @@
   this.isSuper = false
   this.isType = false
   this.type = type;
   this.code = code;
   this.span = span;
   this.needsTemp = needsTemp;
   // Initializers done
   if (this.type == null) world.internalError('type passed as null', this.span);
 }
 Value.prototype.is$Value = function(){return this;};
+Value.prototype.get$type = function() { return this.type; };
+Value.prototype.set$type = function(value) { return this.type = value; };
+Value.prototype.get$code = function() { return this.code; };
+Value.prototype.set$code = function(value) { return this.code = value; };
 Value.prototype.get$span = function() { return this.span; };
 Value.prototype.set$span = function(value) { return this.span = value; };
+Value.prototype.get$isSuper = function() { return this.isSuper; };
+Value.prototype.set$isSuper = function(value) { return this.isSuper = value; };
+Value.prototype.get$isType = function() { return this.isType; };
+Value.prototype.set$isType = function(value) { return this.isType = value; };
+Value.prototype.get$needsTemp = function() { return this.needsTemp; };
+Value.prototype.set$needsTemp = function(value) { return this.needsTemp = value; };
 Value.prototype.get$_typeIsVarOrParameterType = function() {
   return $notnull_bool(this.type.get$isVar() || (this.type instanceof ParameterType));
 }
 Value.prototype.get$isConst = function() {
   return false;
 }
 Value.prototype.get$canonicalCode = function() {
   return null;
 }
 Value.prototype.get_ = function(context, name, node) {
+  var $0;
   var member = this._resolveMember(context, name, node, false);
   if ($notnull_bool($ne(member, null))) {
-    return member._get$3(context, node, this);
+    return (($0 = member._get$3(context, node, this)) && $0.is$Value());
   }
   else {
     return this.invokeNoSuchMethod(context, ('get:' + name + ''), node);
   }
 }
 Value.prototype.set_ = function(context, name, node, value, isDynamic) {
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool($ne(member, null))) {
     return member._set(context, node, this, value, isDynamic);
   }
   else {
     return this.invokeNoSuchMethod(context, ('set:' + name + ''), node, new Arguments(null, [value]));
   }
 }
 Value.prototype.invoke = function(context, name, node, args, isDynamic) {
+  var $0;
   if ($notnull_bool(this.get$_typeIsVarOrParameterType() && name == '\$ne')) {
     if (args.values.length != 1) {
       world.warning('wrong number of arguments for !=', node.span);
     }
     var eq = this.invoke(context, '\$eq', node, args, isDynamic);
     world.gen.corejs.useOperator('\$ne');
-    return new Value(eq.type, ('\$ne(' + this.code + ', ' + args.values.$index(0).code + ')'), node.span, true);
+    return new Value(eq.get$type(), ('\$ne(' + this.code + ', ' + args.values.$index(0).get$code() + ')'), node.span, true);
   }
   if (name == '\$call') {
     if ($notnull_bool(this.isType)) {
       world.error('must use "new" or "const" to construct a new instance', node.span);
     }
     if ($notnull_bool(this.type.needsVarCall(args))) {
       return this._varCall(context, args);
     }
   }
   var member = this._resolveMember(context, name, node, isDynamic);
   if ($notnull_bool(member == null)) {
     return this.invokeNoSuchMethod(context, name, node, args);
   }
   else {
-    return member.invoke$5(context, node, this, args, isDynamic);
+    return (($0 = member.invoke$5(context, node, this, args, isDynamic)) && $0.is$Value());
   }
 }
 Value.prototype.canInvoke = function(context, name, args) {
   if ($notnull_bool(this.get$_typeIsVarOrParameterType() && name == '\$ne')) {
     return true;
   }
   if ($notnull_bool(this.type.get$isVarOrFunction() && name == '\$call')) {
     return true;
   }
   var member = this._resolveMember(context, name, null, true);
   return $notnull_bool($ne(member, null) && member.canInvoke$2(context, args));
 }
 Value.prototype._hasOverriddenNoSuchMethod = function() {
   if ($notnull_bool(this.isSuper)) {
     var m = this.type.getMember('noSuchMethod');
-    return $notnull_bool($ne(m, null) && !$notnull_bool(m.declaringType.get$isObject()));
+    return $notnull_bool($ne(m, null) && !$notnull_bool(m.get$declaringType().get$isObject()));
   }
   else {
     return this.type.resolveMember('noSuchMethod').members.length > 1;
   }
 }
 Value.prototype._tryResolveMember = function(context, name) {
   if ($notnull_bool(this.isSuper)) {
     return this.type.getMember(name);
   }
   else {
@@ skipping 34 matching lines @@
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
   return new Value(world.varType, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), this.span, true);
 }
 Value.prototype.needsConversion = function(toType) {
   var callMethod = toType.getCallMethod();
   if ($notnull_bool($ne(callMethod, null))) {
-    var arity = callMethod.get$parameters().length;
+    var arity = $assert_num(callMethod.get$parameters().length);
     var myCall = this.type.getCallMethod();
-    if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
+    if ($notnull_bool(myCall == null || $ne(myCall.get$parameters().length, arity))) {
       return true;
     }
   }
   if ($notnull_bool(options.enableTypeChecks)) {
     var fromType = this.type;
     if ($notnull_bool(this.type.get$isVar() && this.code != 'null')) {
       fromType = world.objectType;
     }
     var bothNum = $notnull_bool(this.type.get$isNum() && toType.get$isNum());
     return $notnull_bool(fromType.isSubtypeOf(toType) || bothNum);
   }
   return false;
 }
 Value.prototype.convertTo = function(context, toType, node, isDynamic) {
   var $0;
   var checked = !$notnull_bool(isDynamic);
   var callMethod = toType.getCallMethod();
   if ($notnull_bool($ne(callMethod, null))) {
     if ($notnull_bool(checked && !$notnull_bool(toType.isAssignable(this.type)))) {
       this.convertWarning(toType, node);
     }
-    var arity = callMethod.get$parameters().length;
+    var arity = $assert_num(callMethod.get$parameters().length);
     var myCall = this.type.getCallMethod();
-    if ($notnull_bool(myCall == null || myCall.get$parameters().length != arity)) {
+    if ($notnull_bool(myCall == null || $ne(myCall.get$parameters().length, arity))) {
       var stub = world.functionType.getCallStub(Arguments.Arguments$bare$factory(arity));
       var val = new Value(toType, ('to\$' + stub.name + '(' + this.code + ')'), node.span, true);
       return (($0 = $notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type))) ? val._wrapDomCallback(toType, arity) : val) && $0.is$Value());
     }
     else if ($notnull_bool(this._isDomCallback(toType) && !$notnull_bool(this._isDomCallback(this.type)))) {
       return this._wrapDomCallback(toType, arity);
     }
   }
   var fromType = this.type;
   if ($notnull_bool(this.type.get$isVar() && (this.code != 'null' || !$notnull_bool(toType.get$isNullable())))) {
     fromType = world.objectType;
   }
   var bothNum = $notnull_bool(this.type.get$isNum() && toType.get$isNum());
   if ($notnull_bool($notnull_bool(!$notnull_bool(checked) || fromType.isSubtypeOf(toType)) || bothNum)) {
     return this;
   }
   if ($notnull_bool(checked && !$notnull_bool(toType.isSubtypeOf(this.type)))) {
     this.convertWarning(toType, node);
   }
   if ($notnull_bool(options.enableTypeChecks)) {
     return this._typeAssert(context, toType, node);
   }
   else {
     return this;
   }
 }
 Value.prototype._isDomCallback = function(toType) {
-  return ((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom()));
+  return ($notnull_bool((toType.get$definition() instanceof FunctionTypeDefinition) && $eq(toType.get$library(), world.get$dom())));
 }
 Value.prototype._wrapDomCallback = function(toType, arity) {
   return new Value(toType, ('\$wrap_call\$' + arity + '(' + this.code + ')'), this.span, true);
 }
 Value.prototype._typeAssert = function(context, toType, node) {
   if ((toType instanceof ParameterType)) {
     var p = (toType && toType.is$ParameterType());
     toType = p.extendsType;
   }
   if ($notnull_bool(toType.get$isObject() || toType.get$isVar())) {
@@ skipping 14 matching lines @@
   else if ($notnull_bool(toType.get$library().get$isCore() && toType.get$typeofName() != null)) {
     check = ('\$assert_' + toType.name + '(' + this.code + ')');
     if (toType.typeCheckCode == null) {
       toType.typeCheckCode = ("function $assert_" + toType.name + "(x) {\n  if (x == null || typeof(x) == \"" + toType.get$typeofName() + "\") return x;\n  throw new TypeError(\"'\" + x + \"' is not a " + toType.name + ".\");\n}");
     }
   }
   else {
     toType.isTested = true;
     var temp = context.getTemp(this);
     check = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
-    check = check + (' ' + temp.code + '.is\$' + toType.get$jsname() + '())');
+    check = check + (' ' + temp.get$code() + '.is\$' + toType.get$jsname() + '())');
     if ($ne(this, temp)) context.freeTemp((temp && temp.is$Value()));
   }
   return new Value(toType, check, this.span, true);
 }
 Value.prototype.instanceOf = function(context, toType, span, isTrue, forceCheck) {
   if ($notnull_bool(toType.get$isVar())) {
     world.error('can not resolve type', span);
     return EvaluatedValue.EvaluatedValue$factory(world.nonNullBool, true, 'true', null);
   }
   if ((toType instanceof ParameterType)) {
@@ skipping 10 matching lines @@
     toType.markUsed();
     testCode = ('(' + this.code + ' instanceof ' + toType.get$jsname() + ')');
     if (!$notnull_bool(isTrue)) {
       testCode = '!' + testCode;
     }
   }
   if (testCode == null) {
     toType.isTested = true;
     var temp = context.getTemp(this);
     testCode = ('(' + context.assignTemp((temp && temp.is$Value()), this).code + ' &&');
-    testCode = testCode + (' ' + temp.code + '.is\$' + toType.get$jsname() + ')');
+    testCode = testCode + (' ' + temp.get$code() + '.is\$' + toType.get$jsname() + ')');
     if ($notnull_bool(isTrue)) {
       testCode = '!!' + testCode;
     }
     else {
       testCode = '!' + testCode;
     }
     if ($ne(this, temp)) context.freeTemp((temp && temp.is$Value()));
   }
   return new Value(world.nonNullBool, testCode, span, true);
 }
 Value.prototype.convertWarning = function(toType, node) {
   world.warning(('type "' + this.type.name + '" is not assignable to "' + toType.name + '"'), node.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
+  var $0;
   var pos = '';
   if (args != null) {
     var argsCode = [];
     for (var i = 0;
      i < args.get$length(); i++) {
-      argsCode.add$1(args.values.$index(i).code);
+      argsCode.add$1(args.values.$index(i).get$code());
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), node.span, true), new Value(world.listType, ('[' + pos + ']'), node.span, true)];
-  return this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs));
+  return (($0 = this._resolveMember(context, 'noSuchMethod', node, false).invoke$4(context, node, this, new Arguments(null, noSuchArgs))) && $0.is$Value());
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
   $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 449, 12);
   $assert(!$notnull_bool(args.get$hasNames()), "!args.hasNames", "value.dart", 450, 12);
   var argsString = args.getCode();
   if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), this.span, true);
   }
   else {
     if (argsString.length > 0) argsString = (', ' + argsString + '');
@@ skipping 62 matching lines @@
 ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
 ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, span) {
   return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
+ConstListValue.prototype.get$values = function() { return this.values; };
+ConstListValue.prototype.set$values = function(value) { return this.values = value; };
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
 ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, span, code) {
   this.values = values;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
 ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, span) {
   var values = new HashMapImplementation();
   for (var i = 0;
    i < keyValuePairs.length; i += 2) {
     values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
   return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
+ConstMapValue.prototype.get$values = function() { return this.values; };
+ConstMapValue.prototype.set$values = function(value) { return this.values = value; };
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
 ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, span, code) {
   this.fields = fields;
   EvaluatedValue._internal$ctor.call(this, (type && type.is$lang_Type()), actualValue, canonicalCode, (span && span.is$SourceSpan()), $assert_String(code));
   // Initializers done
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
 $inherits(ConstObjectValue, EvaluatedValue);
 ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, span) {
   var fieldValues = [];
   var $list = fields.getKeys();
   for (var $i = fields.getKeys().iterator$0(); $i.hasNext$0(); ) {
     var f = $i.next$0();
     fieldValues.add(('' + f + ' = ' + fields.$index(f).get$actualValue() + ''));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo$1(b);
   })
   );
   var actualValue = ('const ' + type.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
   return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, span, EvaluatedValue.codeWithComments(canonicalCode, span));
 }
+ConstObjectValue.prototype.get$fields = function() { return this.fields; };
+ConstObjectValue.prototype.set$fields = function(value) { return this.fields = value; };
 // ********** Code for GlobalValue **************
 function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, span, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.dependencies = dependencies;
   Value.call(this, type, code, span, !$notnull_bool(isConst));
   // Initializers done
 }
 $inherits(GlobalValue, Value);
 GlobalValue.prototype.is$GlobalValue = function(){return this;};
 GlobalValue.prototype.is$Comparable = function(){return this;};
 GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
   var code = ($notnull_bool(exp.get$isConst()) ? exp.get$canonicalCode() : exp.code);
-  var codeWithComment = ('' + code + '/*' + field.declaringType.name + '.' + field.get$name() + '*/');
-  return new GlobalValue(exp.type, $assert_String(codeWithComment), field.isFinal, field, null, exp, code, exp.span, dependencies.filter$1((function (d) {
+  var codeWithComment = ('' + code + '/*' + field.get$declaringType().get$name() + '.' + field.get$name() + '*/');
+  return new GlobalValue(exp.type, $assert_String(codeWithComment), $assert_bool(field.get$isFinal()), field, null, exp, code, exp.span, dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
 GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
   var name = ("const\$" + uniqueId + "");
   var codeWithComment = ("" + name + "/*" + exp.span.get$text() + "*/");
   return new GlobalValue(exp.type, $assert_String(codeWithComment), true, null, name, exp, name, exp.span, dependencies.filter$1((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
+GlobalValue.prototype.get$field = function() { return this.field; };
+GlobalValue.prototype.set$field = function(value) { return this.field = value; };
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
+GlobalValue.prototype.get$exp = function() { return this.exp; };
+GlobalValue.prototype.set$exp = function(value) { return this.exp = value; };
 GlobalValue.prototype.get$canonicalCode = function() { return this.canonicalCode; };
 GlobalValue.prototype.set$canonicalCode = function(value) { return this.canonicalCode = value; };
 GlobalValue.prototype.get$isConst = function() {
   return $notnull_bool(this.exp.get$isConst() && ($notnull_bool(this.field == null || this.field.isFinal)));
 }
 GlobalValue.prototype.get$actualValue = function() {
   return this.exp.get$dynamic().get$actualValue();
 }
 GlobalValue.prototype.compareTo = function(other) {
   if ($eq(other, this)) {
@@ skipping 87 matching lines @@
   // Initializers done
 }
 World.prototype.get$coreimpl = function() {
   var $0;
   return (($0 = this.libraries.$index('dart:coreimpl')) && $0.is$Library());
 }
 World.prototype.get$dom = function() {
   var $0;
   return (($0 = this.libraries.$index('dart:dom')) && $0.is$Library());
 }
+World.prototype.get$dynamicType = function() { return this.dynamicType; };
+World.prototype.set$dynamicType = function(value) { return this.dynamicType = value; };
 World.prototype.get$functionType = function() { return this.functionType; };
 World.prototype.set$functionType = function(value) { return this.functionType = value; };
 World.prototype.init = function() {
   var $0;
   this.corelib = new Library(this.readFile('dart:core'));
   this.libraries.$setindex('dart:core', this.corelib);
   this._todo.add(this.corelib);
   this.voidType = (($0 = this._addToCoreLib('void', false)) && $0.is$DefinedType());
   this.dynamicType = (($0 = this._addToCoreLib('Dynamic', false)) && $0.is$DefinedType());
   this.varType = this.dynamicType;
@@ skipping 19 matching lines @@
   var mset = this._members.$index(member.name);
   if ($notnull_bool(mset == null)) {
     mset = new MemberSet(member, true);
     this._members.$setindex(mset.get$name(), mset);
   }
   else {
     mset.get$members().add$1(member);
   }
 }
 World.prototype._addTopName = function(named) {
+  var $0;
   var existing = this._topNames.$index(named.get$name());
   if ($notnull_bool($ne(existing, null))) {
-    this.info(('mangling matching top level name "' + named.get$name() + '" in ') + ('both "' + named.get$library().name + '" and "' + existing.get$library().name + '"'));
+    this.info(('mangling matching top level name "' + named.get$name() + '" in ') + ('both "' + named.get$library().name + '" and "' + existing.get$library().get$name() + '"'));
     if ($notnull_bool(named.get$isNative())) {
       if ($notnull_bool(existing.get$isNative())) {
-        world.internalError(('conflicting native names "' + named.get$name() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
+        world.internalError(('conflicting native names "' + named.get$name() + '" ') + ('(already defined in ' + existing.get$span().get$locationText() + ')'), (($0 = named.get$span()) && $0.is$SourceSpan()));
       }
       else {
         this._topNames.$setindex(named.get$name(), named);
         this._addJavascriptTopName((existing && existing.is$Named()));
       }
     }
     else if ($notnull_bool(named.get$library().get$isCore())) {
       if ($notnull_bool(existing.get$library().get$isCore())) {
-        world.internalError(('conflicting top-level names in core "' + named.get$name() + '" ') + ('(previously defined in ' + existing.get$span().get$locationText() + ')'), named.get$span());
+        world.internalError(('conflicting top-level names in core "' + named.get$name() + '" ') + ('(previously defined in ' + existing.get$span().get$locationText() + ')'), (($0 = named.get$span()) && $0.is$SourceSpan()));
       }
       else {
         this._topNames.$setindex(named.get$name(), named);
         this._addJavascriptTopName((existing && existing.is$Named()));
       }
     }
     else {
       this._addJavascriptTopName(named);
     }
   }
   else {
     this._topNames.$setindex(named.get$name(), named);
   }
 }
 World.prototype._addJavascriptTopName = function(named) {
+  var $0;
   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());
+    world.internalError(('name mangling failed for "' + named.get$jsname() + '" ') + ('("' + named.get$jsname() + '" defined also in ' + existing.get$span().get$locationText() + ')'), (($0 = named.get$span()) && $0.is$SourceSpan()));
   }
   this._topNames.$setindex(named.get$jsname(), named);
 }
 World.prototype._addType = function(type) {
   if (!$notnull_bool(type.get$isTop())) this._addTopName(type);
 }
 World.prototype._addToCoreLib = function(name, isClass) {
   var ret = new DefinedType(name, this.corelib, null, isClass);
   this.corelib.types.$setindex(name, ret);
   return ret;
@@ skipping 45 matching lines @@
   var $this = this; // closure support
   var lib = this.withTiming('first pass', (function () {
     return $this.processScript(options.dartScript);
   })
   );
   this.withTiming('resolve top level', (function () {
     $this.resolveAll();
   })
   );
   this.withTiming('generate code', (function () {
-    var mainMembers = lib.topType.resolveMember('main');
+    var $0;
+    var mainMembers = lib.get$topType().resolveMember$1('main');
     var main = null;
-    if ($notnull_bool(mainMembers == null || mainMembers.get$members().length == 0)) {
+    if ($notnull_bool(mainMembers == null || $eq(mainMembers.get$members().length, 0))) {
       $this.fatal('no main method specified');
     }
     else if (mainMembers.get$members().length > 1) {
       var $list = mainMembers.get$members();
       for (var $i = mainMembers.get$members().iterator$0(); $i.hasNext$0(); ) {
         var m = $i.next$0();
         main = m;
-        $this.error('more than one main member (using last?)', main.get$span());
+        $this.error('more than one main member (using last?)', (($0 = main.get$span()) && $0.is$SourceSpan()));
       }
     }
     else {
       main = mainMembers.get$members().$index(0);
     }
     var codeWriter = new CodeWriter();
     $this.gen = new WorldGenerator(main, codeWriter);
     $this.gen.run();
-    $this.jsBytesWritten = codeWriter.get$text().length;
+    $this.jsBytesWritten = $assert_num(codeWriter.get$text().length);
   })
   );
 }
 World.prototype.getGeneratedCode = function() {
   if (this.legCode != null) {
     $assert(options.enableLeg, "options.enableLeg", "world.dart", 310, 14);
     return this.legCode;
   }
   else {
     return this.gen.writer.get$text();
@@ skipping 207 matching lines @@
         continue loop;
 
       default:
 
         if ($notnull_bool(arg.endsWith$1('.dart'))) {
           this.dartScript = $assert_String(arg);
           this.childArgs = (($0 = args.getRange(i + 1, args.length - i - 1)) && $0.is$List$String());
           break loop;
         }
         else if ($notnull_bool(arg.startsWith$1('--out='))) {
-          this.outfile = arg.substring$1('--out='.length);
+          this.outfile = $assert_String(arg.substring$1('--out='.length));
         }
         else if ($notnull_bool(arg.startsWith$1('--libdir='))) {
           this.libDir = $assert_String(arg.substring$1('--libdir='.length));
           passedLibDir = true;
         }
         else {
           if (!$notnull_bool(ignoreUnrecognizedFlags)) {
             print(('unrecognized flag: "' + arg + '"'));
           }
         }
@@ skipping 90 matching lines @@
 };
 // ********** Code for VarMethodStub **************
 function VarMethodStub(name, member, args, body) {
   this.member = member;
   this.args = args;
   this.body = body;
   VarMember.call(this, name);
   // Initializers done
 }
 $inherits(VarMethodStub, VarMember);
+VarMethodStub.prototype.get$body = function() { return this.body; };
 VarMethodStub.prototype.get$returnType = function() {
   var $0;
   return (($0 = this.member != null ? this.member.get$returnType() : world.varType) && $0.is$lang_Type());
 }
 VarMethodStub.prototype.get$typeName = function() {
   return this.member != null ? this.member.declaringType.get$jsname() : 'Object';
 }
 VarMethodStub.prototype.generate = function(code) {
   code.write(('' + this.get$typeName() + '.prototype.' + this.name + ' = '));
   this.generateBody(code, ';');
 }
 VarMethodStub.prototype.generateBody = function(code, end) {
   if ($notnull_bool(this._useDirectCall(this.member, this.args))) {
     code.writeln(('' + this.get$typeName() + '.prototype.' + this.member.get$jsname() + '' + end + ''));
   }
   else {
     code.enterBlock(('function(' + this.args.getCode() + ') {'));
     code.writeln(('return ' + this.body.code + ';'));
     code.exitBlock(('}' + end + ''));
   }
 }
 VarMethodStub.prototype._useDirectCall = function(member, args) {
   if ((member instanceof MethodMember) && $ne(member.declaringType.get$library(), world.get$dom())) {
     var method = (member && member.is$MethodMember());
     if ($notnull_bool(method.needsArgumentConversion(args))) {
       return false;
     }
     for (var i = args.get$length();
      i < method.parameters.length; i++) {
-      if ($notnull_bool($ne(method.parameters.$index(i).get$value().code, 'null'))) {
+      if ($notnull_bool($ne(method.parameters.$index(i).get$value().get$code(), 'null'))) {
         return false;
       }
     }
     return method.namesInOrder(args);
   }
   else {
     return false;
   }
 }
 VarMethodStub.prototype.generate$1 = function($0) {
@@ skipping 20 matching lines @@
   this._invokeMembers(context, node);
   return VarMember.prototype.invoke.call(this, context, node, target, args);
 }
 VarMethodSet.prototype._invokeMembers = function(context, node) {
   if (this._fallbackStubs != null) return;
   var objectStub = null;
   this._fallbackStubs = [];
   var $list = this.members;
   for (var $i = 0;$i < $list.length; $i++) {
     var member = $list.$index($i);
-    var target = new Value(member.declaringType, 'this', node.span, true);
+    var target = new Value(member.get$declaringType(), 'this', node.span, true);
     var result = member.invoke$4(context, node, target, this.args);
     var stub = new VarMethodStub(this.name, member, this.args, result);
-    var type = member.declaringType;
+    var type = member.get$declaringType();
     if ($notnull_bool(type.get$isObject())) {
       objectStub = stub;
     }
-    else if ($ne(type.get$library(), world.get$dom())) {
+    else if ($notnull_bool($ne(type.get$library(), world.get$dom()))) {
       VarMethodSet._addVarStub((type && type.is$lang_Type()), (stub && stub.is$VarMember()));
     }
     else {
       this._fallbackStubs.add(stub);
     }
   }
   if ($notnull_bool(objectStub == null)) {
     var target = new Value(world.objectType, 'this', node.span, true);
     var result = target.invokeNoSuchMethod(context, this.get$baseName(), node, this.args);
     objectStub = new VarMethodStub(this.name, null, this.args, result);
@@ skipping 293 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);