cleanup test status

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.js **************
 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 793 matching lines @@
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if ($notnull_bool(this._numberOfDeleted > numberOfFree)) {
     this._grow(this._keys.length);
   }
 }
 HashMapImplementation._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation.prototype._grow = function(newCapacity) {
-  $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "/Volumes/Data/dart/dart/corelib/src/implementation/hash_map_set.dart", 153, 12);
+  $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "/Users/jimhug/dartfrog/dart/corelib/src/implementation/hash_map_set.dart", 153, 12);
   var capacity = this._keys.length;
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory$V(newCapacity);
   for (var i = 0;
    $notnull_bool(i < capacity); i++) {
     var key = oldKeys.$index(i);
     if ($notnull_bool(key == null || key === HashMapImplementation._deletedKey)) {
@@ skipping 146 matching lines @@
   var numberOfFreeOrDeleted = capacity - newNumberOfEntries;
   var numberOfFree = numberOfFreeOrDeleted - this._numberOfDeleted;
   if ($notnull_bool(this._numberOfDeleted > numberOfFree)) {
     this._grow(this._keys.length);
   }
 }
 HashMapImplementation$E$E._isPowerOfTwo = function(x) {
   return ((x & (x - 1)) == 0);
 }
 HashMapImplementation$E$E.prototype._grow = function(newCapacity) {
-  $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "/Volumes/Data/dart/dart/corelib/src/implementation/hash_map_set.dart", 153, 12);
+  $assert(HashMapImplementation._isPowerOfTwo(newCapacity), "_isPowerOfTwo(newCapacity)", "/Users/jimhug/dartfrog/dart/corelib/src/implementation/hash_map_set.dart", 153, 12);
   var capacity = this._keys.length;
   this._loadLimit = HashMapImplementation._computeLoadLimit(newCapacity);
   var oldKeys = this._keys;
   var oldValues = this._values;
   this._keys = new ListFactory(newCapacity);
   this._values = new ListFactory$E(newCapacity);
   for (var i = 0;
    $notnull_bool(i < capacity); i++) {
     var key = oldKeys.$index(i);
     if ($notnull_bool(key == null || key === HashMapImplementation._deletedKey)) {
@@ skipping 344 matching lines @@
   if ($notnull_bool(entry == null)) return null;
   return entry.get$element().get$value();
 }
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory$K(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
-  $assert(index == this.get$length(), "index == length", "/Volumes/Data/dart/dart/corelib/src/implementation/linked_hash_map.dart", 75, 12);
+  $assert(index == this.get$length(), "index == length", "/Users/jimhug/dartfrog/dart/corelib/src/implementation/linked_hash_map.dart", 75, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.getValues = function() {
   var list = new ListFactory$V(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.value);
   }
   );
-  $assert(index == this.get$length(), "index == length", "/Volumes/Data/dart/dart/corelib/src/implementation/linked_hash_map.dart", 86, 12);
+  $assert(index == this.get$length(), "index == length", "/Users/jimhug/dartfrog/dart/corelib/src/implementation/linked_hash_map.dart", 86, 12);
   return list;
 }
 LinkedHashMapImplementation.prototype.forEach = function(f) {
   this._list.forEach(function _(entry) {
     f(entry.key, entry.value);
   }
   );
 }
 LinkedHashMapImplementation.prototype.containsKey = function(key) {
   return this._map.containsKey(key);
@@ skipping 8822 matching lines @@
   return new SourceSpan(this.baseSource, 0, 0);
 }
 Library.prototype.makeFullPath = function(filename) {
   if ($notnull_bool(filename.startsWith('dart:'))) return filename;
   if ($notnull_bool(filename.startsWith('/'))) return filename;
   if ($notnull_bool(filename.startsWith('file:///'))) return filename;
   if ($notnull_bool(filename.startsWith('http://'))) return filename;
   return joinPaths(this.sourceDir, filename);
 }
 Library.prototype.addImport = function(fullname, prefix) {
-  this.imports.add(new LibraryImport(world.getOrAddLibrary(fullname), prefix));
+  var newLib = world.getOrAddLibrary(fullname);
+  this.imports.add(new LibraryImport(newLib, prefix));
+  return newLib;
 }
 Library.prototype.addNative = function(fullname) {
   this.natives.add(world.reader.readFile(fullname));
 }
 Library.prototype._findMembers = function(name0) {
   if ($notnull_bool(name0.startsWith('_'))) {
     return this._privateMembers.$index(name0);
   }
   else {
     return world._members.$index(name0);
@@ skipping 138 matching lines @@
     if ($notnull_bool(index > 0)) {
       this.name = this.name.substring(0, index);
     }
   }
   var $list = this.types.getValues();
   for (var $i = this.types.getValues().iterator(); $i.hasNext(); ) {
     var type = $i.next();
     type.resolve();
   }
 }
+Library.prototype.visitSources = function() {
+  var visitor = new _LibraryVisitor(this);
+  visitor.addSource(this.baseSource);
+}
 Library.prototype.toString = function() {
   return this.baseSource.filename;
 }
-// ********** Code for LibraryVisitor **************
-function LibraryVisitor(library) {
+// ********** Code for _LibraryVisitor **************
+function _LibraryVisitor(library) {
+  this.seenImport = false
+  this.seenSource = false
+  this.seenResource = false
+  this.isTop = true
   this.library = library;
   // Initializers done
   this.currentType = this.library.topType;
   this.sources = [];
-  this.addSource(this.library.baseSource);
 }
-LibraryVisitor.prototype.get$library = function() { return this.library; };
-LibraryVisitor.prototype.addSourceFromName = function(name) {
+_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 ($notnull_bool(this.sources.some((function (s) {
+    return s.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) {
+_LibraryVisitor.prototype.addSource = function(source) {
+  var $this = this; // closure support
   var $0;
+  if ($notnull_bool(this.library.sources.some((function (s) {
+    return s.filename == source.filename;
+  })
+  ))) {
+    world.error(('duplicate source file "' + source.filename + '"'));
+    return;
+  }
   this.library.sources.add(source);
   var parser = new lang_Parser(source, options.dietParse, 0);
   var unit = parser.compilationUnit();
-  for (var $i = 0;$i < unit.length; $i++) {
-    var def = unit.$index($i);
-    def.visit(this);
-  }
+  unit.forEach((function (def) {
+    return def.visit($this);
+  })
+  );
+  $assert(this.sources.length == 0 || this.isTop, "sources.length == 0 || isTop", "library.dart", 296, 12);
+  this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource((source0 && source0.is$SourceFile()));
   }
 }
-LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
+_LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
+  if ($notnull_bool(!this.isTop)) {
+    world.error('directives not allowed in sourced file', node.span);
+    return;
+  }
   var name;
   switch (node.name.name) {
     case "library":
 
       name = this.getSingleStringArg(node);
       if ($notnull_bool(this.library.name == null)) {
         this.library.name = $assert_String(name);
         if ($notnull_bool($eq(name, 'node') || $eq(name, 'dom'))) {
           this.library.topType.isNativeType = true;
         }
+        if ($notnull_bool(this.seenImport || this.seenSource || this.seenResource)) {
+          world.error('#library must be first directive in file', node.span);
+        }
       }
       else {
         world.error('already specified library name', node.span);
       }
       break;
 
     case "import":
 
+      this.seenImport = true;
       name = this.getFirstStringArg(node);
       var prefix = this.tryGetNamedStringArg(node, 'prefix');
       if ($notnull_bool(node.arguments.length > 2 || node.arguments.length == 2 && prefix == null)) {
         world.error('expected at most one "name" argument and one optional "prefix"' + (' but found ' + node.arguments.length + ''), node.span);
       }
       else if ($notnull_bool($ne(prefix, null) && prefix.indexOf('.', 0) >= 0)) {
         world.error('library prefix canot contain "."', node.span);
       }
+      else if ($notnull_bool(this.seenSource || this.seenResource)) {
+        world.error('#imports must come before any #source or #resource', node.span);
+      }
       if ($notnull_bool($eq(prefix, ''))) prefix = null;
-      this.library.addImport(this.library.makeFullPath($assert_String(name)), $assert_String(prefix));
+      var filename = this.library.makeFullPath($assert_String(name));
+      if ($notnull_bool(this.library.imports.some((function (li) {
+        return $eq(li.get$library().baseSource, filename);
+      })
+      ))) {
+        world.error(('duplicate import of "' + name + '"'), node.span);
+        return;
+      }
+      var newLib = this.library.addImport($assert_String(filename), $assert_String(prefix));
+      if ($notnull_bool(newLib.get$name() == null && !filename.startsWith('dart:'))) {
+        world.info(('imported library "' + name + '" has no #library directive'), node.span);
+      }
       break;
 
     case "source":
 
+      this.seenSource = true;
       name = this.getSingleStringArg(node);
-      this.addSourceFromName($assert_String(name));
+      this.addSourceFromName($assert_String(name), node.span);
+      if ($notnull_bool(this.seenResource)) {
+        world.error('#sources must come before any #resource', node.span);
+      }
       break;
 
     case "native":
 
       name = this.getSingleStringArg(node);
       this.library.addNative(this.library.makeFullPath($assert_String(name)));
       break;
 
     case "resource":
 
+      this.seenResource = true;
       this.getFirstStringArg(node);
       break;
 
     default:
 
       world.error(('unknown directive: ' + node.name.name + ''), node.span);
 
   }
 }
-LibraryVisitor.prototype.getSingleStringArg = function(node) {
+_LibraryVisitor.prototype.getSingleStringArg = function(node) {
   if ($notnull_bool(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) {
+_LibraryVisitor.prototype.getFirstStringArg = function(node) {
   if ($notnull_bool(node.arguments.length < 1)) {
     world.error(('expected at least one argument but found ' + node.arguments.length + ''), node.span);
   }
   var arg = node.arguments.$index(0);
   if ($notnull_bool(arg.label != null)) {
     world.error('label not allowed for directive', node.span);
   }
   return this._parseStringArgument((arg && arg.is$ArgumentNode()));
 }
-LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
+_LibraryVisitor.prototype.tryGetNamedStringArg = function(node, argName) {
   var $0;
   var args = node.arguments.filter((function (a) {
     return a.label != null && a.label.name == argName;
   })
   );
   if ($notnull_bool(args.length == 0)) {
     return null;
   }
   if ($notnull_bool(args.length > 1)) {
     world.error(('expected at most one "' + argName + '" argument but found ') + node.arguments.length, node.span);
   }
   for (var $i = args.iterator(); $i.hasNext(); ) {
     var arg = $i.next();
     return this._parseStringArgument((arg && arg.is$ArgumentNode()));
   }
 }
-LibraryVisitor.prototype._parseStringArgument = function(arg) {
+_LibraryVisitor.prototype._parseStringArgument = function(arg) {
   var expr = arg.value;
   if ($notnull_bool(!(expr instanceof LiteralExpression) || !expr.type.type.get$isString())) {
     world.error('expected string', expr.get$span());
   }
   return parseStringLiteral($assert_String(expr.get$value()));
 }
-LibraryVisitor.prototype.visitTypeDefinition = function(node) {
+_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(this);
   }
   this.currentType = (oldType && oldType.is$lang_Type());
 }
-LibraryVisitor.prototype.visitVariableDefinition = function(node) {
+_LibraryVisitor.prototype.visitVariableDefinition = function(node) {
   this.currentType.addField(node);
 }
-LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
+_LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
-LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
+_LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod('\$call', node.func);
 }
 // ********** Code for lang_Parameter **************
 function lang_Parameter(definition) {
   this.definition = definition;
   // Initializers done
 }
 lang_Parameter.prototype.get$definition = function() { return this.definition; };
 lang_Parameter.prototype.set$definition = function(value) { return this.definition = value; };
 lang_Parameter.prototype.get$name = function() { return this.name; };
 lang_Parameter.prototype.set$name = function(value) { return this.name = value; };
 lang_Parameter.prototype.get$value = function() { return this.value; };
 lang_Parameter.prototype.set$value = function(value) { return this.value = value; };
-lang_Parameter.prototype.resolve = function(inType) {
+lang_Parameter.prototype.resolve = function(method, inType) {
   this.name = this.definition.name.name;
   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 ($notnull_bool(this.definition.value != null)) {
+    if ($notnull_bool((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(!inType.get$isClass())) {
+      world.error('default value not allowed on interface methods', this.definition.span);
+    }
+    else if ($notnull_bool(method.name == '\$call' && method.get$definition().body == null)) {
+      world.error('default value not allowed on function type', this.definition.span);
+    }
+  }
 }
 lang_Parameter.prototype.genValue = function(method, context) {
   var $0;
   if ($notnull_bool(this.definition.value == null || this.value != null)) return;
   if ($notnull_bool(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);
 }
@@ skipping 79 matching lines @@
     world.error('static members can not hide parent members', this.get$span(), other.get$span());
     return false;
   }
   else if ($notnull_bool(other.get$isStatic())) {
     world.error('can not override static member', this.get$span(), other.get$span());
     return false;
   }
   return true;
 }
 Member.prototype.get$generatedFactoryName = function() {
-  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 132, 12);
+  $assert(this.get$isFactory(), "this.isFactory", "member.dart", 157, 12);
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if ($notnull_bool(this.name == '')) {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
 Member.prototype.get_$3 = function($0, $1, $2) {
   return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()));
@@ skipping 29 matching lines @@
 TypeMember.prototype.get$canGet = function() {
   return true;
 }
 TypeMember.prototype.get$canSet = function() {
   return false;
 }
 TypeMember.prototype.resolve = function(inType) {
 
 }
 TypeMember.prototype.get_ = function(context, node, target, isDynamic) {
-  $assert(target == null || target.type.get$isTop(), "target == null || target.type.isTop", "member.dart", 170, 12);
+  $assert(target == null || target.type.get$isTop(), "target == null || target.type.isTop", "member.dart", 195, 12);
   return new Value(this.type, this.type.get$jsname(), false, false, true);
 }
 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 419 matching lines @@
   if ($notnull_bool(this.definition.returnType.names != null)) {
     return this.definition.returnType.names.$index(0).get$name();
   }
   else if ($notnull_bool($ne(this.definition.returnType.get$name(), null))) {
     return this.definition.returnType.get$name().get$name();
   }
   world.internalError('no valid constructor name', this.definition.span);
 }
 MethodMember.prototype.get$functionType = function() {
   if ($notnull_bool(this._functionType == null)) {
-    this._functionType = this.declaringType.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
+    this._functionType = this.get$library().getOrAddFunctionType(this.name, this.definition, this.declaringType);
     if ($notnull_bool(this.parameters == null)) {
       this.resolve(this.declaringType);
     }
   }
   return this._functionType;
 }
 MethodMember.prototype.override = function(other) {
   if ($notnull_bool(!Member.prototype.override.call(this, other))) return false;
   if ($notnull_bool(other.get$isMethod())) {
     return true;
@@ skipping 569 matching lines @@
     this.returnType = inType.resolveType(this.definition.returnType, false);
     if ($notnull_bool(this.isStatic && this.returnType.get$hasTypeParams())) {
       world.error('using type parameter in static context', this.definition.returnType.span);
     }
   }
   this.parameters = [];
   var $list = this.definition.formals;
   for (var $i = 0;$i < $list.length; $i++) {
     var formal = $list.$index($i);
     var param = new lang_Parameter(formal);
-    param.resolve(inType);
+    param.resolve(this, inType);
     this.parameters.add(param);
-    if ($notnull_bool(this.isStatic && param.type.get$hasTypeParams())) {
-      world.error('using type parameter in static context', formal.get$span());
-    }
   }
   if ($notnull_bool(!this.isLambda)) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.get_$3 = function($0, $1, $2) {
   return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
 ;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
@@ skipping 24 matching lines @@
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
-MemberSet.prototype.get$library = function() {
-  var ret = this.members.$index(0).declaringType.get$library();
-  var $list = this.members;
-  for (var $i = 0;$i < $list.length; $i++) {
-    var m = $list.$index($i);
-    if ($notnull_bool($ne(m.declaringType.get$library(), ret))) return null;
-  }
-  return ret;
-}
 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(null, ('' + target.code + '.' + this.jsname + '() /*no applicable ' + action + '*/'), false, true, false);
 }
 MemberSet.prototype.get$treatAsField = function() {
   if ($notnull_bool(this._treatAsField == null)) {
     this._treatAsField = true;
     var $list = this.members;
@@ skipping 5874 matching lines @@
     e = $toDartException(e);
     this.warning(('Error reading file: ' + filename + ''));
     return new SourceFile(filename, '');
   }
 }
 World.prototype.getOrAddLibrary = function(filename) {
   var library = this.libraries.$index(filename);
   if ($notnull_bool(library == null)) {
     library = new Library(this.readFile(filename));
     this.info(('read library ' + filename + ''));
-    if ($notnull_bool(!library.get$isCore())) {
+    if ($notnull_bool(!library.get$isCore() && !library.imports.some((function (li) {
+      return li.get$library().get$isCore();
+    })
+    ))) {
       library.imports.add(new LibraryImport(this.corelib));
     }
     this.libraries.$setindex(filename, library);
     this._todo.add(library);
   }
   return library;
 }
 World.prototype.process = function() {
   while ($notnull_bool(this._todo.length > 0)) {
     var todo = this._todo;
     this._todo = [];
     for (var $i = 0;$i < todo.length; $i++) {
       var lib = todo.$index($i);
-      new LibraryVisitor(lib);
+      lib.visitSources();
     }
   }
 }
 World.prototype.processScript = function(filename) {
   var library = this.getOrAddLibrary(filename);
   this.process();
   return library;
 }
 World.prototype.resolveAll = function() {
   var $0;
@@ skipping 667 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();