cleanup from r3556

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $defProp(obj, prop, value) {
   Object.defineProperty(obj, prop,
       {value: value, enumerable: false, writable: true, configurable: true});
 }
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
@@ skipping 1679 matching lines @@
     table.push({tag: tag, tags: tags, map: map});
   }
   $dynamicMetadata = table;
 }
 $dynamic("end$0").WriteStream = function() {
   return this.end();
 };
 $dynamic("write$1").WriteStream = function($0) {
   return this.write($0, "utf8");
 };
+// ********** Code for Fs **************
+Fs.from$ctor = function(_fs) {
+  this._fs = _fs;
+}
+Fs.from$ctor.prototype = Fs.prototype;
+function Fs() {}
+Fs.prototype.realpathSync = function(path) {
+  return this._fs.realpathSync(path);
+}
+Fs.prototype.readFileSync = function(filename, encoding) {
+  return this._fs.readFileSync(filename, encoding);
+}
+Fs.prototype.writeFileSync = function(filename, data, encoding) {
+  this._fs.writeFileSync(filename, data, encoding);
+}
 // ********** Code for fs_FSWatcher **************
 // ********** Code for top level **************
 function get$fs() {
-  return require("fs");
+  return new Fs.from$ctor(require("fs"));
 }
 //  ********** Library node **************
 // ********** Code for Process **************
 function Process(_process) {
   this.SIGSYS = "SIGSYS";
   this.SIGALRM = "SIGALRM";
   this.SIGXCPU = "SIGXCPU";
   this.SIGTSTP = "SIGTSTP";
   this.SIGSEGV = "SIGSEGV";
   this.SIGQUIT = "SIGQUIT";
@@ skipping 9568 matching lines @@
 }
 Type.prototype.get$isJsGlobalObject = function() {
   return (this.get$nativeType() != null && this.get$nativeType().isJsGlobalObject);
 }
 Type.prototype.get$hasTypeParams = function() {
   return false;
 }
 Type.prototype.get$typeofName = function() {
   return null;
 }
+Type.prototype.get$fullname = function() {
+  return this.get$library().name != null ? ("" + this.get$library().name + "." + this.name) : this.name;
+}
 Type.prototype.get$members = function() {
   return null;
 }
 Type.prototype.get$definition = function() {
   return null;
 }
 Type.prototype.get$factories = function() {
   return null;
 }
 Type.prototype.get$typeArgsInOrder = function() {
@@ skipping 832 matching lines @@
     }
     if (!typeArg.get$isVar()) allVar = false;
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArg);
     names.add(typeArg.get$name());
     jsnames.add(typeArg.get$jsname());
   }
   if (allVar) return this;
   var jsname = ("" + this.get$jsname() + "_" + Strings.join(jsnames, "$"));
   var simpleName = ("" + this.name + "<" + Strings.join(names, ", ") + ">");
-  var key = Strings.join(names, "$");
-  var ret = this._concreteTypes.$index(key);
+  var ret = this._concreteTypes.$index(jsname);
   if ($eq(ret)) {
     ret = new DefinedType(simpleName, this.library, this.definition, this.isClass);
     ret.set$baseGenericType(this);
     ret.set$typeArgsInOrder(typeArgs);
     ret.set$_jsname(jsname);
-    this._concreteTypes.$setindex(key, ret);
+    this._concreteTypes.$setindex(jsname, ret);
     ret.resolve();
   }
   return ret;
 }
 DefinedType.prototype.getCallStub = function(args) {
   var name = _getCallStubName("call", args);
   var stub = this.varStubs.$index(name);
   if ($eq(stub)) {
     stub = new VarFunctionStub(name, args);
     this.varStubs.$setindex(name, stub);
@@ skipping 542 matching lines @@
       testCode = $add("!", testCode);
     }
     if ($ne(this, temp)) context.freeTemp(temp);
     if (!$globals.world.objectType.varStubs.containsKey(checkName)) {
       $globals.world.objectType.varStubs.$setindex(checkName, new VarMethodStub(checkName, null, Arguments.get$EMPTY(), "return false"));
     }
   }
   return new Value($globals.world.nonNullBool, testCode, span);
 }
 Value.prototype.convertWarning = function(toType) {
-  $globals.world.warning(("type \"" + this.get$type().name + "\" is not assignable to \"" + toType.name + "\""), this.span);
+  $globals.world.warning(("type \"" + this.get$type().get$fullname() + "\" is not assignable to \"" + toType.get$fullname() + "\""), this.span);
 }
 Value.prototype.invokeNoSuchMethod = function(context, name, node, args) {
   if (this.get$isType()) {
     $globals.world.error(("member lookup failed for \"" + name + "\""), node.span);
   }
   var pos = "";
   if (args != null) {
     var argsCode = [];
     for (var i = (0);
      i < args.get$length(); i++) {
@@ skipping 62 matching lines @@
 }
 PureStaticValue.prototype.set_ = function(context, name, node, value, kind, returnKind) {
   if (this.get$type().get$isVar()) return new PureStaticValue($globals.world.varType, node.span, false, false);
   var member = this.getMem(context, name, node);
   if ($ne(member)) {
     member._set(context, node, this, value);
   }
   return new PureStaticValue(value.get$type(), node.span, false, false);
 }
 PureStaticValue.prototype.setIndex = function(context, index, node, value, kind, returnKind) {
-  return this.invoke(context, ":setindex", node, new Arguments(null, [index, value]));
+  var tmp = this.invoke(context, ":setindex", node, new Arguments(null, [index, value]));
+  return new PureStaticValue(value.get$type(), node.span, false, false);
 }
 PureStaticValue.prototype.unop = function(kind, context, node) {
   switch (kind) {
     case (19):
 
       return new PureStaticValue($globals.world.boolType, node.get$span(), false, false);
 
     case (42):
 
       if (!this.isConst && !this.get$type().get$isNum()) {
@@ skipping 1799 matching lines @@
 }
 var const$0000 = Object.create(_DeletedKeySentinel.prototype, {});
 var const$0001 = Object.create(NoMoreElementsException.prototype, {});
 var const$0002 = Object.create(EmptyQueueException.prototype, {});
 var const$0006 = Object.create(IllegalAccessException.prototype, {});
 var const$0007 = ImmutableList.ImmutableList$from$factory([]);
 var const$0009 = new JSSyntaxRegExp("^[a-zA-Z]:/");
 var $globals = {};
 $static_init();
 main();