cleanup errors and fix a couple field negative tests

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 8760 matching lines @@
   this._usedTemps = new HashSetImplementation();
   this._freeTemps = [];
 }
 MethodGenerator.prototype.is$MethodGenerator = function(){return this;};
 MethodGenerator.prototype.findMembers = function(name) {
   return this.method.get$library()._findMembers(name);
 }
 MethodGenerator.prototype.get$isClosure = function() {
   return (this.enclosingMethod != null);
 }
+MethodGenerator.prototype.get$isStatic = function() {
+  return this.method.get$isStatic();
+}
 MethodGenerator.prototype.getTemp = function(value) {
   return $notnull_bool(value.needsTemp) ? this.forceTemp(value) : value;
 }
 MethodGenerator.prototype.forceTemp = function(value) {
   var name;
   if ($notnull_bool(this._freeTemps.length > 0)) {
     name = $assert_String(this._freeTemps.removeLast());
   }
   else {
     name = '\$' + this._usedTemps.get$length();
@@ skipping 84 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", 651, 14);
+    $assert(this._usedTemps.get$length() == 0, "_usedTemps.length == 0", "gen.dart", 653, 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 628 matching lines @@
   }
   var value = this.visitVoid(node.body);
   this.writer.writeln(('' + value.code + ';'));
   return false;
 }
 MethodGenerator.prototype.visitEmptyStatement = function(node) {
   this.writer.writeln(';');
   return false;
 }
 MethodGenerator.prototype._checkNonStatic = function(node) {
-  if ($notnull_bool(this.method.get$isStatic())) {
+  if ($notnull_bool(this.get$isStatic())) {
     world.warning('not allowed in static method', node.span);
   }
 }
 MethodGenerator.prototype._makeSuperValue = function(node) {
   var parentType = this.method.declaringType.get$parent();
   this._checkNonStatic(node);
   if ($notnull_bool(parentType == null)) {
     world.error('no super class', node.span);
   }
   return new Value(parentType, 'this', true, true, false);
@@ skipping 459 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", 2018, 12);
+  $assert($ne(type, null), "type != null", "gen.dart", 2020, 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 260 matching lines @@
     var imported = $list.$index($i);
     var newRet = null;
     if ($notnull_bool(imported.prefix == null)) {
       newRet = imported.get$library().types.$index(name0);
     }
     else if ($notnull_bool(imported.prefix == name0)) {
       newRet = imported.get$library().topType;
     }
     if ($notnull_bool($ne(newRet, null))) {
       if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-        world.error(('conflicting types for "' + name0 + '"'), ret.get$span());
-        world.error(('conflicting types for "' + name0 + '"'), newRet.get$span());
+        world.error(('conflicting types for "' + name0 + '"'), ret.get$span(), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
   }
   return ret;
 }
 Library.prototype.lookup = function(name0, span0) {
   var retType = this.findTypeByName(name0);
   var ret = null;
   if ($notnull_bool($ne(retType, null))) {
     ret = retType.get$typeMember();
   }
   var newRet = this.topType.getMember(name0);
   if ($notnull_bool($ne(newRet, null))) {
     if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-      world.error(('conflicting members for "' + name0 + '"'), span0);
-      world.error(('conflicting members for "' + name0 + '"'), ret.get$span());
-      world.error(('conflicting members for "' + name0 + '"'), newRet.get$span());
+      world.error(('conflicting members for "' + name0 + '"'), span0, ret.get$span(), newRet.get$span());
     }
     else {
       ret = newRet;
     }
   }
   var $list = this.imports;
   for (var $i = 0;$i < $list.length; $i++) {
     var imported = $list.$index($i);
     if ($notnull_bool(imported.prefix == null)) {
       newRet = imported.get$library().topType.getMember(name0);
       if ($notnull_bool($ne(newRet, null))) {
         if ($notnull_bool($ne(ret, null) && $ne(ret, newRet))) {
-          world.error(('conflicting members for "' + name0 + '"'), span0);
-          world.error(('conflicting members for "' + name0 + '"'), ret.get$span());
-          world.error(('conflicting members for "' + name0 + '"'), newRet.get$span());
+          world.error(('conflicting members for "' + name0 + '"'), span0, ret.get$span(), newRet.get$span());
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   return ret;
 }
 Library.prototype.resolve = function() {
@@ skipping 62 matching lines @@
     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();
   unit.forEach((function (def) {
     return def.visit($this);
   })
   );
-  $assert(this.sources.length == 0 || this.isTop, "sources.length == 0 || isTop", "library.dart", 296, 12);
+  $assert(this.sources.length == 0 || this.isTop, "sources.length == 0 || isTop", "library.dart", 293, 12);
   this.isTop = false;
   var newSources = this.sources;
   this.sources = [];
   for (var $i = newSources.iterator(); $i.hasNext(); ) {
     var source0 = $i.next();
     this.addSource((source0 && source0.is$SourceFile()));
   }
 }
 _LibraryVisitor.prototype.visitDirectiveDefinition = function(node) {
   if ($notnull_bool(!this.isTop)) {
@@ skipping 36 matching lines @@
       if ($notnull_bool($eq(prefix, ''))) prefix = null;
       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), node.span);
       if ($notnull_bool(this.seenResource)) {
         world.error('#sources must come before any #resource', node.span);
       }
@@ skipping 354 matching lines @@
       }
       else {
         world.error(('' + mod + ' modifier not allowed on field'), mod.get$span());
       }
     }
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(this.isStatic && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.type.span);
   }
+  if ($notnull_bool(this.isStatic && this.isFinal && this.value == null)) {
+    world.error('static final field is missing initializer', this.get$span());
+  }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   var $0;
   if ($notnull_bool(this.value == null)) return null;
   if ($notnull_bool(this._computedValue == null)) {
     if ($notnull_bool(this._computing)) {
       world.error('circular reference', this.value.span);
       return null;
     }
@@ skipping 946 matching lines @@
 }
 MemberSet.prototype.get$containsMethods = function() {
   return this.members.some((function (m) {
     return (m instanceof MethodMember);
   })
   );
 }
 MemberSet.prototype.add = function(member) {
   return this.members.add(member);
 }
+MemberSet.prototype.get$isStatic = function() {
+  return this.members.length == 1 && this.members.$index(0).get$isStatic();
+}
 MemberSet.prototype.canInvoke = function(context, args) {
   return this.members.some((function (m) {
     return m.canInvoke(context, args);
   })
   );
 }
 MemberSet.prototype._makeError = function(node, target, action) {
   if ($notnull_bool(!target.type.get$isVar())) {
     world.warning(('could not find applicable ' + action + ' for "' + this.name + '"'), node.span);
   }
@@ skipping 4883 matching lines @@
   if ($notnull_bool(method.get$isConstructor())) {
     if ($notnull_bool(this.constructors.containsKey(method.get$constructorName()))) {
       world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition0.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
   if ($notnull_bool(definition0.modifiers != null && definition0.modifiers.length == 1 && definition0.modifiers.$index(0).kind == 75/*TokenKind.FACTORY*/)) {
     if ($notnull_bool(this.factories.getFactory(method.get$constructorName(), $assert_String(method.get$name())) != null)) {
-      world.error(('duplicate factory definition of ' + method.get$name() + ''), definition0.span);
+      world.error(('duplicate factory definition of "' + method.get$name() + '"'), definition0.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), $assert_String(method.get$name()), (method && method.is$Member()));
     return;
   }
   if ($notnull_bool(methodName.startsWith('get\$') || methodName.startsWith('set\$'))) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
     if ($notnull_bool(prop == null)) {
       prop = new PropertyMember($assert_String(propName), this);
       this.members.$setindex(propName, prop);
     }
     if ($notnull_bool(!(prop instanceof PropertyMember))) {
-      world.error(('property conflicts with field name: ' + propName + ''), definition0.span);
+      world.error(('property conflicts with field "' + propName + '"'), definition0.span);
       return;
     }
     if ($notnull_bool(methodName[0] == 'g')) {
       if ($notnull_bool(prop.getter != null)) {
-        world.error(('duplicate getter definition for ' + propName + ''), definition0.span);
+        world.error(('duplicate getter definition for "' + propName + '"'), definition0.span);
       }
       prop.getter = (method && method.is$MethodMember());
     }
     else {
       if ($notnull_bool(prop.setter != null)) {
-        world.error(('duplicate setter definition for ' + propName + ''), definition0.span);
+        world.error(('duplicate setter definition for "' + propName + '"'), definition0.span);
       }
       prop.setter = (method && method.is$MethodMember());
     }
     return;
   }
   if ($notnull_bool(this.members.containsKey(methodName))) {
-    world.error(('duplicate method definition of ' + method.get$name() + ''), definition0.span);
+    world.error(('duplicate method definition of "' + method.get$name() + '"'), definition0.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
 DefinedType.prototype.addField = function(definition0) {
   for (var i = 0;
    $notnull_bool(i < definition0.names.length); i++) {
     var name0 = definition0.names.$index(i).get$name();
     if ($notnull_bool(this.members.containsKey(name0))) {
-      world.error(('duplicate field definition of ' + name0 + ''), definition0.span);
+      world.error(('duplicate field definition of "' + name0 + '"'), definition0.span);
       return;
     }
     var value = null;
     if ($notnull_bool(definition0.values != null)) {
       value = definition0.values.$index(i);
     }
     var field = new FieldMember($assert_String(name0), this, definition0, value);
     this.members.$setindex(name0, field);
     if ($notnull_bool(this.isNativeType)) {
       field.isNative = true;
@@ skipping 209 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", 1136, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1135, 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", 1156, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1155, 12);
   var name0 = _getCallStubName('call', args);
   if ($notnull_bool(this.varStubs == null)) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name0);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name0), args);
     this.varStubs.$setindex(name0, stub);
   }
   return stub;
 }
 // ********** Code for FixedCollection **************
@@ skipping 132 matching lines @@
       member = this.type.resolveMember(name);
     }
   }
   if ($notnull_bool(member == null)) {
     member = context.findMembers(name);
   }
   return member;
 }
 Value.prototype._resolveMember = function(context, name, node) {
   var member = this._tryResolveMember(context, name);
-  if ($notnull_bool(member == null)) {
+  if ($notnull_bool($ne(member, null))) {
+    if ($notnull_bool(this.isType && !member.get$isStatic())) {
+      world.error('can not refer to instance member as static', node.span);
+    }
+    return member;
+  }
+  else {
     if ($notnull_bool(this._tryResolveMember(context, 'noSuchMethod').members.length > 1)) {
       return null;
     }
     var typeName = $notnull_bool(this.type.name == null) ? this.type.get$library().name : this.type.name;
     var message = ('can not resolve "' + name + '" on "' + typeName + '"');
     if ($notnull_bool(this.isType)) {
       world.error($assert_String(message), node.span);
     }
     else {
       world.warning($assert_String(message), node.span);
     }
     if ($notnull_bool(context.findMembers(name) == null)) {
       world.warning(('' + name + ' is not defined anywhere in the world.'), node.span);
     }
+    return null;
   }
-  return member;
 }
 Value.prototype.checkFirstClass = function(span) {
   if ($notnull_bool(this.isType)) {
     world.error('Types are not first class', span);
   }
 }
 Value.prototype._varCall = function(context, args) {
   var stub = world.functionType.getCallStub(args);
   return new Value(null, ('' + this.code + '.' + stub.get$name() + '(' + args.getCode() + ')'), false, true, false);
 }
@@ skipping 134 matching lines @@
     for (var i = 0;
      $notnull_bool(i < args.get$length()); i++) {
       argsCode.add(args.values.$index(i).code);
     }
     pos = Strings.join((argsCode && argsCode.is$List$String()), ", ");
   }
   var noSuchArgs = [new Value(world.stringType, ('"' + name + '"'), false, true, false), new Value(world.listType, ('[' + pos + ']'), false, true, false)];
   return this._tryResolveMember(context, 'noSuchMethod').invoke$4(context, node, this, new Arguments(null, noSuchArgs));
 }
 Value.prototype.invokeSpecial = function(name, args, returnType) {
-  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 410, 12);
-  $assert(!args.get$hasNames(), "!args.hasNames", "value.dart", 411, 12);
+  $assert(name.startsWith('\$'), "name.startsWith('\\$')", "value.dart", 417, 12);
+  $assert(!args.get$hasNames(), "!args.hasNames", "value.dart", 418, 12);
   var argsString = args.getCode();
   if ($notnull_bool(name == '\$index' || name == '\$setindex')) {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
     if ($notnull_bool(argsString.length > 0)) argsString = (', ' + argsString + '');
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
 Value.prototype.get_$3 = function($0, $1, $2) {
@@ skipping 395 matching lines @@
   return library;
 }
 World.prototype.resolveAll = function() {
   var $0;
   var $list = this.libraries.getValues();
   for (var $i = this.libraries.getValues().iterator(); $i.hasNext(); ) {
     var lib = $i.next();
     lib.resolve();
   }
 }
-World.prototype._message = function(message, span, span1, throwing) {
+World.prototype._message = function(message, span, span1, span2, throwing) {
   var text = message;
   if ($notnull_bool(span != null)) {
     text = span.toMessageString(message);
   }
   print(text);
   if ($notnull_bool(span1 != null)) {
     print(span1.toMessageString(message));
   }
+  if ($notnull_bool(span2 != null)) {
+    print(span2.toMessageString(message));
+  }
   if ($notnull_bool(throwing)) {
     $throw(new CompilerException(message, span));
   }
 }
-World.prototype.error = function(message, span, span1) {
+World.prototype.error = function(message, span, span1, span2) {
   this.errors++;
-  this._message(('error: ' + message + ''), span, span1, options.throwOnErrors);
+  this._message(('error: ' + message + ''), span, span1, span2, options.throwOnErrors);
 }
-World.prototype.warning = function(message, span, span1) {
+World.prototype.warning = function(message, span, span1, span2) {
   this.warnings++;
   if ($notnull_bool(options.showWarnings)) {
-    this._message(('warning: ' + message + ''), span, span1, options.throwOnWarnings);
+    this._message(('warning: ' + message + ''), span, span1, span2, options.throwOnWarnings);
   }
 }
-World.prototype.fatal = function(message, span, span1) {
+World.prototype.fatal = function(message, span, span1, span2) {
   this.errors++;
   this.seenFatal = true;
-  this._message(('fatal: ' + message + ''), span, span1, $assert_bool(options.throwOnFatal || options.throwOnErrors));
+  this._message(('fatal: ' + message + ''), span, span1, span2, $assert_bool(options.throwOnFatal || options.throwOnErrors));
 }
-World.prototype.internalError = function(message, span, span1) {
-  this._message(('We are sorry, but... ' + message + ''), span, span1, true);
+World.prototype.internalError = function(message, span, span1, span2) {
+  this._message(('We are sorry, but... ' + message + ''), span, span1, span2, true);
 }
-World.prototype.info = function(message, span, span1) {
+World.prototype.info = function(message, span, span1, span2) {
   if ($notnull_bool(options.showInfo)) {
-    this._message(('info: ' + message + ''), span, span1, false);
+    this._message(('info: ' + message + ''), span, span1, span2, false);
   }
 }
 World.prototype.get$hasErrors = function() {
   return this.errors > 0;
 }
 World.prototype.printStatus = function() {
   this.info(('compiled ' + this.dartBytesRead + ' bytes Dart -> ' + this.jsBytesWritten + ' bytes JS'));
   if ($notnull_bool(this.get$hasErrors())) {
     print(('compilation failed with ' + this.errors + ' errors'));
   }
@@ skipping 617 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();