Adding in-browser correctness testing via selenium.

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 1041 matching lines @@
 ImmutableMap.prototype.$index = function(key) {
   return this._internal.$index(key);
 }
 ImmutableMap.prototype.isEmpty = function() {
   return this._internal.isEmpty();
 }
 ImmutableMap.prototype.get$length = function() {
   return this._internal.get$length();
 }
 Object.defineProperty(ImmutableMap.prototype, "length", {
-  get: ImmutableMap.prototype.get$length,
+  get: ImmutableMap.prototype.get$length
 });
 ImmutableMap.prototype.forEach = function(f) {
   this._internal.forEach(f);
 }
 ImmutableMap.prototype.getKeys = function() {
   return this._internal.getKeys();
 }
 ImmutableMap.prototype.getValues = function() {
   return this._internal.getValues();
 }
@@ skipping 208 matching lines @@
   }
   return null;
 }
 HashMapImplementation.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation.prototype.get$length = function() {
   return this._numberOfEntries;
 }
 Object.defineProperty(HashMapImplementation.prototype, "length", {
-  get: HashMapImplementation.prototype.get$length,
+  get: HashMapImplementation.prototype.get$length
 });
 HashMapImplementation.prototype.forEach = function(f) {
   var length = this._keys.length;
   for (var i = 0;
    $notnull_bool(i < length); i++) {
     if ($notnull_bool((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey))) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
@@ skipping 353 matching lines @@
   var keys = this._backingMap.getKeys();
   return keys.some(f);
 }
 HashSetImplementation.prototype.isEmpty = function() {
   return this._backingMap.isEmpty();
 }
 HashSetImplementation.prototype.get$length = function() {
   return this._backingMap.get$length();
 }
 Object.defineProperty(HashSetImplementation.prototype, "length", {
-  get: HashSetImplementation.prototype.get$length,
+  get: HashSetImplementation.prototype.get$length
 });
 HashSetImplementation.prototype.iterator = function() {
   return new HashSetIterator$E(this);
 }
 // ********** Code for HashSetImplementation$E **************
 function HashSetImplementation$E() {
   // Initializers done
   this._backingMap = new HashMapImplementation$E$E();
 }
 $inherits(HashSetImplementation$E, HashSetImplementation);
@@ skipping 137 matching lines @@
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
 }
 LinkedHashMapImplementation.prototype.get$length = function() {
   return this._map.get$length();
 }
 Object.defineProperty(LinkedHashMapImplementation.prototype, "length", {
-  get: LinkedHashMapImplementation.prototype.get$length,
+  get: LinkedHashMapImplementation.prototype.get$length
 });
 LinkedHashMapImplementation.prototype.isEmpty = function() {
   return this.get$length() == 0;
 }
 // ********** Code for LinkedHashMapImplementation$Node$Element **************
 function LinkedHashMapImplementation$Node$Element() {
   // Initializers done
   this._map = new HashMapImplementation$Node$DoubleLinkedQueueEntry$KeyValuePair$Node$Element();
   this._list = new DoubleLinkedQueue$KeyValuePair$Node$Element();
 }
@@ skipping 202 matching lines @@
 }
 DoubleLinkedQueue.prototype.get$length = function() {
   var counter = 0;
   this.forEach(function _(element) {
     counter++;
   }
   );
   return counter;
 }
 Object.defineProperty(DoubleLinkedQueue.prototype, "length", {
-  get: DoubleLinkedQueue.prototype.get$length,
+  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 ($notnull_bool(entry !== this._sentinel)) {
     f(entry._element);
     entry = entry._next;
   }
@@ skipping 133 matching lines @@
 // ********** Code for StringBufferImpl **************
 function StringBufferImpl(content) {
   // Initializers done
   this.clear();
   this.add(content);
 }
 StringBufferImpl.prototype.get$length = function() {
   return this._length;
 }
 Object.defineProperty(StringBufferImpl.prototype, "length", {
-  get: StringBufferImpl.prototype.get$length,
+  get: StringBufferImpl.prototype.get$length
 });
 StringBufferImpl.prototype.isEmpty = function() {
   return this._length == 0;
 }
 StringBufferImpl.prototype.add = function(obj) {
   var str = obj.toString();
   if ($notnull_bool(str == null || str.isEmpty())) return this;
   this._buffer.add(str);
   this._length += str.length;
   return this;
@@ skipping 8422 matching lines @@
       this.writer.writeln(('' + field.declaringType.get$jsname() + '.prototype.set\$' + field.get$jsname() + ' = ') + ('function(value) { return this.' + field.get$jsname() + ' = value; };'));
     }
   }
 }
 WorldGenerator.prototype._writeProperty = function(property) {
   if ($notnull_bool(property.getter != null)) this._writeMethod(property.getter);
   if ($notnull_bool(property.setter != null)) this._writeMethod(property.setter);
   if ($notnull_bool(property._provideFieldSyntax)) {
     this.writer.enterBlock('Object.defineProperty(' + ('' + property.declaringType.get$jsname() + '.prototype, "' + property.get$jsname() + '", {'));
     if ($notnull_bool(property.getter != null)) {
-      this.writer.writeln(('get: ' + property.declaringType.get$jsname() + '.prototype.' + property.getter.get$jsname() + ','));
+      this.writer.write(('get: ' + property.declaringType.get$jsname() + '.prototype.' + property.getter.get$jsname() + ''));
+      this.writer.writeln($notnull_bool(property.setter == null) ? '' : ',');
     }
     if ($notnull_bool(property.setter != null)) {
       this.writer.writeln(('set: ' + property.declaringType.get$jsname() + '.prototype.' + property.setter.get$jsname() + ''));
     }
     this.writer.exitBlock('});');
   }
 }
 WorldGenerator.prototype._writeMethod = function(method) {
   if ($notnull_bool(method.generator != null)) {
     method.generator.writeDefinition(this.writer, null);
@@ skipping 266 matching lines @@
   else if ($notnull_bool(this.method.get$isStatic())) {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   else {
     defWriter.enterBlock(('' + this.method.declaringType.get$jsname() + '.prototype.') + ('' + this.method.get$jsname() + ' = function' + _params + ' {'));
   }
   if ($notnull_bool(this.needsThis)) {
     defWriter.writeln('var \$this = this; // closure support');
   }
   if ($notnull_bool(this._usedTemps.get$length() > 0 || this._freeTemps.length > 0)) {
-    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 694, 14);
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 697, 14);
     this._freeTemps.addAll(this._usedTemps);
     this._freeTemps.sort((function (x, y) {
       return x.compareTo(y);
     })
     );
     defWriter.writeln(('var ' + Strings.join(this._freeTemps, ", ") + ';'));
   }
   defWriter.writeln(this.writer.get$text());
   if ($notnull_bool($ne(names, null))) {
     defWriter.exitBlock(('}).bind(null, ' + Strings.join((names && names.is$List$String()), ", ") + ')'));
@@ skipping 1117 matching lines @@
 }
 MethodGenerator.prototype.visitSuperExpression = function(node) {
   return this._makeSuperValue(node);
 }
 MethodGenerator.prototype.visitNullExpression = function(node) {
   return EvaluatedValue.EvaluatedValue$factory(null, null, 'null', null);
 }
 MethodGenerator.prototype.visitLiteralExpression = function(node) {
   var $0;
   var type = node.type.type;
-  $assert($ne(type, null), "type != null", "gen.dart", 2072, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2075, 12);
   if ($notnull_bool(!!(($0 = node.value) && $0.is$List))) {
     var items = [];
     var $list = node.value;
     for (var $i = node.value.iterator(); $i.hasNext(); ) {
       var item = $i.next();
       var val = this.visitValue((item && item.is$lang_Expression()));
       val.invoke$4(this, 'toString', item, Arguments.get$EMPTY());
       var code = val.code;
       if ($notnull_bool((item instanceof BinaryExpression) || (item instanceof ConditionalExpression))) {
         code = ('(' + code + ')');
@@ skipping 49 matching lines @@
 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,
+  get: Arguments.prototype.get$length
 });
 Arguments.prototype.getName = function(i) {
   return this.nodes.$index(i).label.name;
 }
 Arguments.prototype.getIndexOfName = function(name) {
   for (var i = this.get$bareCount();
    $notnull_bool(i < this.get$length()); i++) {
     if ($notnull_bool(this.getName(i) == name)) {
       return i;
     }
@@ skipping 6345 matching lines @@
     if ($notnull_bool($ne(newType, t))) needsNewType = true;
     newTypeArgs.add(newType);
   }
   if ($notnull_bool(!$notnull_bool(needsNewType))) return this;
   return this.genericType.getOrMakeConcreteType((newTypeArgs && newTypeArgs.is$List$Type()));
 }
 ConcreteType.prototype.getOrMakeConcreteType = function(typeArgs) {
   return this.genericType.getOrMakeConcreteType(typeArgs);
 }
 ConcreteType.prototype.get$parent = function() {
-  return this.genericType.parent;
+  return this.genericType.get$parent();
 }
 ConcreteType.prototype.get$interfaces = function() {
   if ($notnull_bool(this._interfaces == null && this.genericType.interfaces != null)) {
     this._interfaces = [];
     var $list = this.genericType.interfaces;
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams(this));
     }
   }
@@ skipping 90 matching lines @@
   lang_Type.call(this, name);
   // Initializers done
   this.setDefinition(definition);
 }
 $inherits(DefinedType, lang_Type);
 DefinedType.prototype.is$DefinedType = function(){return this;};
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
-DefinedType.prototype.get$parent = function() { return this.parent; };
-DefinedType.prototype.set$parent = function(value) { return this.parent = value; };
+DefinedType.prototype.get$parent = function() {
+  return this._parent;
+}
+DefinedType.prototype.set$parent = function(p) {
+  return this._parent = p;
+}
 DefinedType.prototype.get$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
 DefinedType.prototype.get$typeParameters = function() { return this.typeParameters; };
 DefinedType.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 DefinedType.prototype.get$constructors = function() { return this.constructors; };
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 558, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 563, 12);
   this.definition = def;
   if ($notnull_bool((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null)) {
     this.isNativeType = true;
   }
   if ($notnull_bool(this.definition != null && this.definition.get$typeParameters() != null)) {
     this._concreteTypes = $map([]);
     this.typeParameters = [];
     var $list = this.definition.get$typeParameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
@@ skipping 60 matching lines @@
   if ($notnull_bool(this.isUsed)) return;
   this.isUsed = true;
   if ($notnull_bool(this._lazyGenMethods != null)) {
     var $list = orderValuesByKeys(this._lazyGenMethods);
     for (var $i = 0;$i < $list.length; $i++) {
       var method = $list.$index($i);
       world.gen.genMethod((method && method.is$Member()));
     }
     this._lazyGenMethods = null;
   }
-  if ($notnull_bool(this.parent != null)) this.parent.markUsed();
+  if ($notnull_bool(this.get$parent() != null)) this.get$parent().markUsed();
 }
 DefinedType.prototype.genMethod = function(method) {
   if ($notnull_bool(this.isUsed)) {
     world.gen.genMethod(method);
   }
   else if ($notnull_bool(this.isClass)) {
     if ($notnull_bool(this._lazyGenMethods == null)) this._lazyGenMethods = $map([]);
     this._lazyGenMethods.$setindex(method.name, method);
   }
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
   if ($notnull_bool(types == null)) return [];
   var interfaces = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed() && !$notnull_bool((this.library.get$isCore() || this.library.get$isCoreImpl())))) {
       world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', type.get$span());
     }
     resolvedInterface.addDirectSubtype(this);
     interfaces.add(resolvedInterface);
   }
   return interfaces;
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 674, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 679, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if ($notnull_bool(this._subtypes == null)) {
     this._subtypes = new HashSetImplementation$Type();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext(); ) {
       var st = $i.next();
       this._subtypes.add(st);
       this._subtypes.addAll(st.get$subtypes());
     }
   }
   return this._subtypes;
 }
 DefinedType.prototype._cycleInClassExtends = function() {
   var seen = new HashSetImplementation();
   seen.add(this);
-  var ancestor = this.parent;
+  var ancestor = this.get$parent();
   while ($notnull_bool($ne(ancestor, null))) {
     if ($notnull_bool(ancestor === this)) {
       return true;
     }
     if ($notnull_bool(seen.contains(ancestor))) {
       return false;
     }
     seen.add(ancestor);
     ancestor = ancestor.get$parent();
   }
@@ skipping 32 matching lines @@
   if ($notnull_bool((this.definition instanceof TypeDefinition))) {
     var typeDef = (($0 = this.definition) && $0.is$TypeDefinition());
     if ($notnull_bool(this.isClass)) {
       if ($notnull_bool(typeDef.extendsTypes != null && typeDef.extendsTypes.length > 0)) {
         if ($notnull_bool(typeDef.extendsTypes.length > 1)) {
           world.error('more than one base class', typeDef.extendsTypes.$index(1).get$span());
         }
         var extendsTypeRef = typeDef.extendsTypes.$index(0);
         if ($notnull_bool((extendsTypeRef instanceof GenericTypeReference))) {
           var g = (extendsTypeRef && extendsTypeRef.is$GenericTypeReference());
-          this.parent = this.resolveType(g.baseType, true);
+          this.set$parent(this.resolveType(g.baseType, true));
         }
-        this.parent = this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true);
-        if ($notnull_bool(!$notnull_bool(this.parent.get$isClass()))) {
+        this.set$parent(this.resolveType((extendsTypeRef && extendsTypeRef.is$TypeReference()), true));
+        if ($notnull_bool(!$notnull_bool(this.get$parent().get$isClass()))) {
           world.error('class may not extend an interface - use implements', typeDef.extendsTypes.$index(0).get$span());
         }
-        this.parent.addDirectSubtype(this);
+        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());
         }
       }
       else {
         if ($notnull_bool(!$notnull_bool(this.get$isObject()))) {
-          this.parent = world.objectType;
+          this.set$parent(world.objectType);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
       if ($notnull_bool(typeDef.factoryType != null)) {
         world.error('factory not allowed on classes', typeDef.factoryType.span);
       }
     }
     else {
       if ($notnull_bool(typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0)) {
         world.error('implements not allowed on interfaces (use extends)', typeDef.implementsTypes.$index(0).get$span());
@@ skipping 163 matching lines @@
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return libType.get$typeMember();
     }
   }
   return this.getMemberInParents(memberName);
 }
 DefinedType.prototype.getMemberInParents = function(memberName) {
   if ($notnull_bool(this.isClass)) {
-    if ($notnull_bool(this.parent != null)) {
-      return this.parent.getMember(memberName);
+    if ($notnull_bool(this.get$parent() != null)) {
+      return this.get$parent().getMember(memberName);
     }
     else if ($notnull_bool(this.get$isObject())) {
       if ($notnull_bool(memberName == '\$ne')) {
         var ret = this._createNotEqualMember();
         this.members.$setindex(memberName, ret);
         return ret;
       }
       return null;
     }
   }
@@ skipping 137 matching lines @@
   }
   else {
     world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1156, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1161, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    $notnull_bool(i < typeArgs.length); i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return ret;
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1176, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1181, 12);
   var name = _getCallStubName('call', args);
   if ($notnull_bool(this.varStubs == null)) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return stub;
 }
 // ********** Code for FixedCollection **************
@@ skipping 881 matching lines @@
       case '--ignore-unrecognized-flags':
 
         ignoreUnrecognizedFlags = true;
         continue loop;
 
       case '--verbose':
 
         this.showInfo = true;
         continue loop;
 
+      case '--suppress_warnings':
+
+        this.showWarnings = false;
+        continue loop;
+
       case '--throw_on_errors':
 
         this.throwOnErrors = true;
         continue loop;
 
       case '--throw_on_warnings':
 
         this.throwOnWarnings = true;
         continue loop;
 
@@ skipping 200 matching lines @@
     world.gen.corejs.useVarMethod = true;
   }
 }
 VarMethodSet._addVarStub = function(type, stub) {
   if ($notnull_bool(type.varStubs == null)) type.varStubs = $map([]);
   type.varStubs.$setindex(stub.name, stub);
 }
 VarMethodSet.prototype.generate = function(code) {
   if ($notnull_bool(this._fallbackStubs.length == 0)) return;
   code.enterBlock(('\$varMethod("' + this.name + '", {'));
+  var lastOne = this._fallbackStubs.$index(this._fallbackStubs.length - 1);
   var $list = this._fallbackStubs;
   for (var $i = 0;$i < $list.length; $i++) {
     var stub = $list.$index($i);
     code.write(('"' + stub.get$typeName() + '": '));
     stub.generateBody(code);
-    code.writeln(',');
+    code.writeln($notnull_bool($eq(stub, lastOne)) ? '' : ',');
   }
   code.exitBlock('});');
 }
 VarMethodSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 }
 ;
 // ********** Code for top level **************
 function map(source, mapper) {
   var $0;
@@ skipping 260 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);