Fixes a few different issues related to block scope.

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 543 matching lines @@
 ListIterator.prototype.hasNext = function() {
   return this._array.length > this._pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$9/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._pos++);
 }
 // ********** Code for ImmutableList **************
-function ImmutableList(length) {
-  this._length = length;
-  ListFactory$E.call(this, length);
+function ImmutableList(length0) {
+  this._length = length0;
+  ListFactory$E.call(this, length0);
   // Initializers done
 }
 $inherits(ImmutableList, ListFactory$E);
 ImmutableList.ImmutableList$from$factory = function(other) {
   var list = new ImmutableList(other.length);
   for (var i = 0;
    i < other.length; i++) {
     list._setindex(i, other.$index(i));
   }
   return list;
 }
 ImmutableList.prototype.get$length = function() {
   return this._length;
 }
-ImmutableList.prototype.set$length = function(length) {
+ImmutableList.prototype.set$length = function(length0) {
   $throw(const$0/*const IllegalAccessException()*/);
 }
 Object.defineProperty(ImmutableList.prototype, "length", {
   get: ImmutableList.prototype.get$length,
   set: ImmutableList.prototype.set$length
 });
 ImmutableList.prototype._setindex = function(index, value) {
   return this[index] = value;
 }
 ImmutableList.prototype.$setindex = function(index, value) {
@@ skipping 56 matching lines @@
       this.ignoreCase = this.re.ignoreCase;
 }
 JSSyntaxRegExp._create$ctor.prototype = JSSyntaxRegExp.prototype;
 JSSyntaxRegExp.prototype.firstMatch = function(str) {
   var m = this.re.exec(str);
     return m && new MatchImplementation(
         this.pattern, str, m.index, this.re.lastIndex, m);
 }
 // ********** Code for MatchImplementation **************
 function MatchImplementation() {}
-MatchImplementation.prototype.$index = function(group) {
-  return this._groups.$index(group);
+MatchImplementation.prototype.$index = function(group0) {
+  return this._groups.$index(group0);
 }
 // ********** Code for _AllMatchesIterable **************
 function _AllMatchesIterable() {}
 _AllMatchesIterable.prototype.iterator = function() {
   return new _AllMatchesIterator(this._re, this._str);
 }
 // ********** Code for _AllMatchesIterator **************
 function _AllMatchesIterator(re, _str) {
   this._str = _str;
   this._done = false;
   this._re = new JSSyntaxRegExp._create$ctor(re.pattern, 'g' + (re.multiLine ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
   // Initializers done
 }
 _AllMatchesIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$9/*const NoMoreElementsException()*/);
   }
-  var next = this._next;
+  var next0 = this._next;
   this._next = null;
-  return next;
+  return next0;
 }
 _AllMatchesIterator.prototype.hasNext = function() {
   if (this._done) {
     return false;
   }
   else if (this._next) {
     return true;
   }
   this._next = this._re.firstMatch(this._str);
   if (this._next == null) {
@@ skipping 151 matching lines @@
   var result = new HashMapImplementation();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
-HashMapImplementation._firstProbe = function(hashCode, length) {
-  return hashCode & (length - 1);
+HashMapImplementation._firstProbe = function(hashCode, length0) {
+  return hashCode & (length0 - 1);
 }
-HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - 1);
+HashMapImplementation._nextProbe = function(currentProbe, numberOfProbes, length0) {
+  return (currentProbe + numberOfProbes) & (length0 - 1);
 }
 HashMapImplementation.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
@@ skipping 84 matching lines @@
 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,
 });
 HashMapImplementation.prototype.forEach = function(f) {
-  var length = this._keys.length;
+  var length0 = this._keys.length;
   for (var i = 0;
-   i < length; i++) {
+   i < length0; i++) {
     if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory$K(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
@@ skipping 23 matching lines @@
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory$E(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 $inherits(HashMapImplementation$E$E, HashMapImplementation);
 HashMapImplementation$E$E._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
-HashMapImplementation$E$E._firstProbe = function(hashCode, length) {
-  return hashCode & (length - 1);
+HashMapImplementation$E$E._firstProbe = function(hashCode, length0) {
+  return hashCode & (length0 - 1);
 }
-HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length) {
-  return (currentProbe + numberOfProbes) & (length - 1);
+HashMapImplementation$E$E._nextProbe = function(currentProbe, numberOfProbes, length0) {
+  return (currentProbe + numberOfProbes) & (length0 - 1);
 }
 HashMapImplementation$E$E.prototype._probeForAdding = function(key) {
   var hash = HashMapImplementation._firstProbe(key.hashCode(), this._keys.length);
   var numberOfProbes = 1;
   var initialHash = hash;
   var insertionIndex = -1;
   while (true) {
     var existingKey = this._keys.$index(hash);
     if (existingKey == null) {
       if (insertionIndex < 0) return hash;
@@ skipping 73 matching lines @@
     this._keys.$setindex(index, HashMapImplementation._deletedKey);
     this._numberOfDeleted++;
     return value;
   }
   return null;
 }
 HashMapImplementation$E$E.prototype.isEmpty = function() {
   return this._numberOfEntries == 0;
 }
 HashMapImplementation$E$E.prototype.forEach = function(f) {
-  var length = this._keys.length;
+  var length0 = this._keys.length;
   for (var i = 0;
-   i < length; i++) {
+   i < length0; i++) {
     if ((this._keys.$index(i) != null) && (this._keys.$index(i) !== HashMapImplementation._deletedKey)) {
       f(this._keys.$index(i), this._values.$index(i));
     }
   }
 }
 HashMapImplementation$E$E.prototype.getKeys = function() {
   var list = new ListFactory$E(this.get$length());
   var i = 0;
   this.forEach(function _(key, value) {
     list.$setindex(i++, key);
@@ skipping 3990 matching lines @@
   this.listener.beginLibraryTag(token);
   token = this.parseIdentifier(this.next(token));
   token = this.expect(const$358/*const SourceString("(")*/, token);
   while (token != null && token.kind != 40/*null.LPAREN_TOKEN*/ && token.kind != 41/*null.RPAREN_TOKEN*/) {
     token = this.next(token);
   }
   token = this.expect(const$359/*const SourceString(")")*/, token);
   return this.expect(const$360/*const SourceString(";")*/, token);
 }
 // ********** Code for BodyParser **************
-function BodyParser(listener) {
-  Parser.call(this, listener);
+function BodyParser(listener0) {
+  Parser.call(this, listener0);
   // Initializers done
 }
 $inherits(BodyParser, Parser);
 BodyParser.prototype.parseFunction = function(token) {
   this.listener.beginFunction(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName(token);
   token = this.parseFormalParameters(token);
@@ skipping 250 matching lines @@
   this.beginToken = beginToken;
   this.builderFunction = builderFunction;
   // Initializers done
 }
 DeclarationBuilder.prototype.get$name = function() { return this.name; };
 DeclarationBuilder.prototype.set$name = function(value) { return this.name = value; };
 DeclarationBuilder.prototype.build = function() {
   return (this.builderFunction)(this);
 }
 // ********** Code for PartialFunctionElement **************
-function PartialFunctionElement(name, beginToken, endToken) {
+function PartialFunctionElement(name0, beginToken, endToken) {
   this.beginToken = beginToken;
   this.endToken = endToken;
-  Element.call(this, name);
+  Element.call(this, name0);
   // Initializers done
 }
 $inherits(PartialFunctionElement, Element);
 PartialFunctionElement.prototype.parseNode = function(canceler, logger) {
   if (this.node == null) {
     var listener = new BodyListener(canceler, logger);
     new BodyParser(listener).parseFunction(this.beginToken);
     logger.log(("parsed function: " + listener.functionExpression + ""));
     this.node = listener.functionExpression;
   }
@@ skipping 32 matching lines @@
   var head = this.expressions.get$head();
   this.expressions = this.expressions.get$tail();
   return head;
 }
 ExpressionContext.prototype.popAll = function() {
   var result = this.expressions;
   this.expressions = const$351/*const EmptyLink<DeclarationBuilder>()*/;
   return result;
 }
 // ********** Code for BodyListener **************
-function BodyListener(canceler, logger) {
+function BodyListener(canceler0, logger) {
   this.logger = logger;
   this.expressionContext = new ExpressionContext(null);
-  Listener.call(this, canceler);
+  Listener.call(this, canceler0);
   // Initializers done
 }
 $inherits(BodyListener, Listener);
 BodyListener.prototype.beginFormalParameters = function(token) {
   this.functionContext.beginFormalsToken = token;
 }
 BodyListener.prototype.endFormalParameters = function(token) {
   this.functionContext.buildFormals(token);
 }
 BodyListener.prototype.beginArguments = function(token) {
@@ skipping 110 matching lines @@
 // ********** Code for Token **************
 function Token(kind, charOffset) {
   this.kind = kind;
   this.charOffset = charOffset;
   // Initializers done
 }
 Token.prototype.toString = function() {
   return Strings.String$fromCharCodes$factory([this.kind]);
 }
 // ********** Code for KeywordToken **************
-function KeywordToken(value, charOffset) {
+function KeywordToken(value, charOffset0) {
   this.value = value;
-  Token.call(this, 107/*null.KEYWORD_TOKEN*/, charOffset);
+  Token.call(this, 107/*null.KEYWORD_TOKEN*/, charOffset0);
   // Initializers done
 }
 $inherits(KeywordToken, Token);
 KeywordToken.prototype.get$value = function() { return this.value; };
 KeywordToken.prototype.toString = function() {
   return this.value.syntax;
 }
 // ********** Code for StringToken **************
-function StringToken(kind, value, charOffset) {
-  this.value = new StringWrapper(value);
-  Token.call(this, kind, charOffset);
+function StringToken(kind0, value0, charOffset0) {
+  this.value = new StringWrapper(value0);
+  Token.call(this, kind0, charOffset0);
   // Initializers done
 }
 $inherits(StringToken, Token);
 StringToken.prototype.get$value = function() { return this.value; };
 StringToken.prototype.toString = function() {
   return this.value.toString();
 }
 // ********** Code for StringWrapper **************
 function StringWrapper(internalString) {
   this.internalString = internalString;
@@ skipping 17 matching lines @@
 }
 Keyword.prototype.is$SourceString = function(){return this;};
 Keyword.get$keywords = function() {
   if (Keyword._keywords == null) {
     Keyword._keywords = Keyword.computeKeywordMap();
   }
   return Keyword._keywords;
 }
 Keyword.computeKeywordMap = function() {
   var result = new LinkedHashMapImplementation$String$Keyword();
-  for (var $i = const$347/*Keyword.values*/.iterator(); $i.hasNext(); ) {
-    var keyword = $i.next();
+  for (var $i0 = const$347/*Keyword.values*/.iterator(); $i0.hasNext(); ) {
+    var keyword = $i0.next();
     result.$setindex(keyword.syntax, keyword);
   }
   return result;
 }
 Keyword.prototype.hashCode = function() {
   return this.syntax.hashCode();
 }
 Keyword.prototype.$eq = function(other) {
   return !!(other && other.is$SourceString) && this.toString() == other.toString();
 }
@@ skipping 239 matching lines @@
 Identifier.prototype.get$source = function() {
   return this.token.get$value();
 }
 Identifier.prototype.accept = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 Identifier.prototype.get$beginToken = function() {
   return this.token;
 }
 // ********** Code for Operator **************
-function Operator(token) {
-  Identifier.call(this, token);
+function Operator(token0) {
+  Identifier.call(this, token0);
   // Initializers done
 }
 $inherits(Operator, Identifier);
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
 Operator.prototype.get$beginToken = function() {
   return this.token;
 }
 // ********** Code for Parameter **************
@@ skipping 62 matching lines @@
   this.enclosingElement = enclosingElement;
   // Initializers done
 }
 Element.prototype.get$name = function() { return this.name; };
 Element.prototype.hashCode = function() {
   return this.name.hashCode();
 }
 // ********** Code for top level **************
 //  ********** Library ssa **************
 // ********** Code for SsaBuilderTask **************
-function SsaBuilderTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function SsaBuilderTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(SsaBuilderTask, CompilerTask);
 SsaBuilderTask.prototype.get$name = function() {
   return 'SSA builder';
 }
 SsaBuilderTask.prototype.build = function(tree) {
   var $this = this; // closure support
   return this.measure((function () {
     var function_ = tree;
@@ skipping 84 matching lines @@
 }
 SsaBuilder.prototype.visitReturn = function(node) {
   this.visit(node.expression);
   var value = this.pop();
   this.add(new HReturn(value));
 }
 SsaBuilder.prototype.visitTypeAnnotation = function(node) {
 
 }
 // ********** Code for SsaCodeGeneratorTask **************
-function SsaCodeGeneratorTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function SsaCodeGeneratorTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
 SsaCodeGeneratorTask.prototype.get$name = function() {
   return 'SSA code generator';
 }
 SsaCodeGeneratorTask.prototype.generate = function(tree, graph) {
   var $this = this; // closure support
   return this.measure((function () {
     var function_ = tree;
-    var name = function_.name;
-    var code = $this.generateMethod(name.get$source(), graph);
+    var name0 = function_.name;
+    var code = $this.generateMethod(name0.get$source(), graph);
     return code;
   })
   );
 }
 SsaCodeGeneratorTask.prototype.generateMethod = function(methodName, graph) {
   var buffer = new StringBufferImpl("");
   var codegen = new SsaCodeGenerator(this.pipeline, buffer);
   graph.number();
   codegen.visitGraph(graph);
   return ('function ' + methodName + '() {\n' + buffer + '}\n');
@@ skipping 148 matching lines @@
 }
 $inherits(HBaseVisitor, HGraphVisitor);
 HBaseVisitor.prototype.visitBasicBlock = function(node) {
   this.currentBlock = node;
   var instruction = node.first;
   while (instruction != null) {
     instruction.accept(this);
     instruction = instruction.next;
   }
 }
-HBaseVisitor.prototype.visitInstruction = function(HInstruction) {
+HBaseVisitor.prototype.visitInstruction = function(HInstruction0) {
 
 }
 HBaseVisitor.prototype.visitAdd = function(node) {
   return this.visitInvoke(node);
 }
 HBaseVisitor.prototype.visitGoto = function(node) {
   return this.visitInstruction(node);
 }
 HBaseVisitor.prototype.visitInvoke = function(node) {
   return this.visitInstruction(node);
@@ skipping 124 matching lines @@
     }
   }
   this._usedBy = null;
 }
 HInstruction.prototype.isValid = function() {
   var validator = new HValidator();
   validator.visitInstruction(this);
   return validator.isValid;
 }
 // ********** Code for HInvoke **************
-function HInvoke(selector, inputs) {
+function HInvoke(selector, inputs0) {
   this.selector = selector;
-  HInstruction.call(this, inputs);
+  HInstruction.call(this, inputs0);
   // Initializers done
 }
 $inherits(HInvoke, HInstruction);
 HInvoke.prototype.toString = function() {
   return ('invoke: ' + this.selector + '');
 }
 HInvoke.prototype.hasSideEffects = function() {
   return true;
 }
 HInvoke.prototype.accept = function(visitor) {
   return visitor.visitInvoke(this);
 }
 // ********** Code for HAdd **************
-function HAdd(inputs) {
-  HInvoke.call(this, const$370/*const SourceString('+')*/, inputs);
+function HAdd(inputs0) {
+  HInvoke.call(this, const$370/*const SourceString('+')*/, inputs0);
   // Initializers done
 }
 $inherits(HAdd, HInvoke);
 HAdd.prototype.hasSideEffects = function() {
   return true;
 }
 HAdd.prototype.accept = function(visitor) {
   return visitor.visitAdd(this);
 }
 // ********** Code for HGoto **************
@@ skipping 34 matching lines @@
 HReturn.prototype.toString = function() {
   return 'return';
 }
 HReturn.prototype.hasSideEffects = function() {
   return true;
 }
 HReturn.prototype.accept = function(visitor) {
   return visitor.visitReturn(this);
 }
 // ********** Code for SsaOptimizerTask **************
-function SsaOptimizerTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function SsaOptimizerTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(SsaOptimizerTask, CompilerTask);
 SsaOptimizerTask.prototype.get$name = function() {
   return 'SSA optimizer';
 }
 SsaOptimizerTask.prototype.optimize = function(graph) {
   this.measure((function () {
     new SsaConstantFolder().visitGraph(graph);
     new SsaDeadCodeEliminator().visitGraph(graph);
@@ skipping 137 matching lines @@
     return HValidator.everyInstruction(instruction0.get$usedBy(), (function (use, count) {
       return HValidator.countInstruction(use.inputs, instruction0) == count;
     })
     );
   }
   this.isValid = this.isValid && hasCorrectInputs(instruction) && hasCorrectUses(instruction);
 }
 // ********** Code for top level **************
 //  ********** Library leg **************
 // ********** Code for WorldPipeline **************
-function WorldPipeline(world, script) {
+function WorldPipeline(world, script0) {
   this.world = world;
-  Pipeline.call(this, script);
+  Pipeline.call(this, script0);
   // Initializers done
 }
 $inherits(WorldPipeline, Pipeline);
 WorldPipeline.prototype.log = function(message) {
   if (options.showInfo) {
     this.world.info(('[leg] ' + message + ''));
   }
 }
 WorldPipeline.prototype.run = function() {
   var success = Pipeline.prototype.run.call(this);
   if (success) {
     var code = this.getGeneratedCode();
     this.world.legCode = code;
     this.world.jsBytesWritten = code.length;
     var $list = this.tasks;
-    for (var $i = 0;$i < $list.length; $i++) {
-      var task = $list.$index($i);
+    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;
 }
 WorldPipeline.prototype.spanFromNode = function(node) {
   var token = node.get$beginToken();
   if (token == null) {
     this.cancel(('cannot find token for node ' + node + ' to produce error message.'));
   }
@@ skipping 82 matching lines @@
 // ********** Code for PipelineCancelledException **************
 function PipelineCancelledException(reason) {
   this.reason = reason;
   // Initializers done
 }
 PipelineCancelledException.prototype.toString = function() {
   var banner = 'pipeline cancelled';
   return (this.reason != null) ? ('' + banner + ': ' + this.reason + '') : ('' + banner + '');
 }
 // ********** Code for ResolverTask **************
-function ResolverTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function ResolverTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(ResolverTask, CompilerTask);
 ResolverTask.prototype.get$name = function() {
   return 'Resolver';
 }
 ResolverTask.prototype.resolve = function(tree) {
   var $this = this; // closure support
   return this.measure((function () {
     var visitor = new ResolverVisitor($this.pipeline, new Types());
     visitor.visit(tree);
     return visitor.elements;
   })
   );
 }
 // ********** Code for ResolverVisitor **************
-function ResolverVisitor(pipeline, types) {
+function ResolverVisitor(pipeline0, types) {
   this.types = types;
-  this.context = new Context(null, pipeline.universe.scope, pipeline.universe.elements);
+  this.context = new Context(null, pipeline0.universe.scope, pipeline0.universe.elements);
   this.elements = new HashMapImplementation$Node$Element();
-  this.pipeline = pipeline;
+  this.pipeline = pipeline0;
   // Initializers done
 }
 ResolverVisitor.prototype.fail = function(node) {
   this.pipeline.cancel(('cannot resolve ' + node.get$debugString() + ''));
 }
 ResolverVisitor.prototype.getType = function(annotation) {
   if (annotation == null || annotation.typeName == null) {
     return this.types.DYNAMIC;
   }
   var name = annotation.typeName.get$source();
@@ skipping 44 matching lines @@
    !link.isEmpty(); link = link.get$tail()) {
     this.visit(link.get$head());
   }
 }
 ResolverVisitor.prototype.visitExpressionStatement = function(node) {
   this.visit(node.expression);
 }
 ResolverVisitor.prototype.visitFunctionExpression = function(node) {
   var returnType = this.getType(node.returnType);
   var parameterTypes = [];
-  var elements = $map([]);
+  var elements0 = $map([]);
   for (var link = node.parameters.nodes;
    !link.isEmpty(); link = link.get$tail()) {
     var parameter = link.get$head();
     var parameterElement = this.visit(parameter);
-    elements.$setindex(parameter.get$name(), parameterElement);
+    elements0.$setindex(parameter.get$name(), parameterElement);
     parameterTypes.add(parameterElement.type);
   }
   var type = new FunctionType(returnType, LinkFactory.Link$fromList$factory(parameterTypes));
   var element = null;
   var name = node.name;
   if (name != null) {
     element = this.context.lookup(name.get$source());
     element.type = type;
   }
-  this.visitIn(node.body, new Context(this.context, element, elements));
+  this.visitIn(node.body, new Context(this.context, element, elements0));
   return element;
 }
 ResolverVisitor.prototype.visitIdentifier = function(node) {
   var element = this.context.lookup(node.get$source());
   if (element == null) this.fail(node);
   return element;
 }
 ResolverVisitor.prototype.visitInvocation = function(node) {
   var selector = node.selector;
   var target = this.pipeline.universe.find(selector.get$source());
@@ skipping 28 matching lines @@
   return new Element(this.context.element, node.name, this.getType(node.typeAnnotation));
 }
 ResolverVisitor.prototype.visitReturn = function(node) {
   this.visit(node.expression);
   return null;
 }
 ResolverVisitor.prototype.visitTypeAnnotation = function(node) {
 
 }
 // ********** Code for Context **************
-function Context(parent, element, elements) {
+function Context(parent, element, elements0) {
   this.parent = parent;
   this.element = element;
-  this.elements = (elements == null) ? $map([]) : elements;
+  this.elements = (elements0 == null) ? $map([]) : elements0;
   // Initializers done
 }
 Context.prototype.get$parent = function() { return this.parent; };
 Context.prototype.get$element = function() { return this.element; };
 Context.prototype.lookup = function(name) {
   if (this.elements != null && this.elements.$index(name) != null) {
     return this.elements.$index(name);
   }
   else if (this.parent != null) {
     return this.parent.lookup(name);
   }
   else {
     return null;
   }
 }
 // ********** Code for ScannerTask **************
-function ScannerTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function ScannerTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(ScannerTask, CompilerTask);
 ScannerTask.prototype.get$name = function() {
   return 'Scanner';
 }
 ScannerTask.prototype.scan = function(script) {
   var $this = this; // closure support
   this.measure((function () {
     var elements = $this.scanElements(script.get$text());
@@ skipping 13 matching lines @@
 }
 // ********** Code for leg_Script **************
 function leg_Script(file) {
   this.file = file;
   // Initializers done
 }
 leg_Script.prototype.get$text = function() {
   return this.file.get$text();
 }
 // ********** Code for TypeCheckerTask **************
-function TypeCheckerTask(pipeline) {
-  CompilerTask.call(this, pipeline);
+function TypeCheckerTask(pipeline0) {
+  CompilerTask.call(this, pipeline0);
   // Initializers done
 }
 $inherits(TypeCheckerTask, CompilerTask);
 TypeCheckerTask.prototype.get$name = function() {
   return "Type checker";
 }
 TypeCheckerTask.prototype.check = function(tree, elements) {
   var $this = this; // closure support
   this.measure((function () {
     var visitor = new TypeCheckerVisitor($this.pipeline, elements, new Types());
@@ skipping 180 matching lines @@
 CodeWriter.prototype.get$text = function() {
   return this._buf.toString();
 }
 CodeWriter.prototype._indent = function() {
   this._pendingIndent = false;
   for (var i = 0;
    i < this._indentation; i++) {
     this._buf.add('  '/*CodeWriter.INDENTATION*/);
   }
 }
-CodeWriter.prototype.comment = function(text) {
+CodeWriter.prototype.comment = function(text0) {
   if (this.writeComments) {
-    this.writeln(text);
+    this.writeln(text0);
   }
 }
-CodeWriter.prototype.write = function(text) {
-  if (text.length == 0) return;
+CodeWriter.prototype.write = function(text0) {
+  if (text0.length == 0) return;
   if (this._pendingIndent) this._indent();
-  if (text.indexOf('\n', 0) != -1) {
-    var lines = text.split('\n');
+  if (text0.indexOf('\n', 0) != -1) {
+    var lines = text0.split('\n');
     for (var i = 0;
      i < lines.length - 1; i++) {
       this.writeln(lines.$index(i));
     }
     this.write(lines.$index(lines.length - 1));
   }
   else {
-    this._buf.add(text);
+    this._buf.add(text0);
   }
 }
-CodeWriter.prototype.writeln = function(text) {
-  if (text != null) {
-    this.write(text);
+CodeWriter.prototype.writeln = function(text0) {
+  if (text0 != null) {
+    this.write(text0);
   }
-  if (!text.endsWith('\n')) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
+  if (!text0.endsWith('\n')) this._buf.add('\n'/*CodeWriter.NEWLINE*/);
   this._pendingIndent = true;
 }
-CodeWriter.prototype.enterBlock = function(text) {
-  this.writeln(text);
+CodeWriter.prototype.enterBlock = function(text0) {
+  this.writeln(text0);
   this._indentation++;
 }
-CodeWriter.prototype.exitBlock = function(text) {
+CodeWriter.prototype.exitBlock = function(text0) {
   this._indentation--;
-  this.writeln(text);
+  this.writeln(text0);
 }
-CodeWriter.prototype.nextBlock = function(text) {
+CodeWriter.prototype.nextBlock = function(text0) {
   this._indentation--;
-  this.writeln(text);
+  this.writeln(text0);
   this._indentation++;
 }
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
   this.main = main;
   this.writer = writer;
   this.globals = $map([]);
   // Initializers done
 }
 WorldGenerator.prototype.run = function() {
@@ skipping 238 matching lines @@
   for (var $i = list.iterator(); $i.hasNext(); ) {
     var global = $i.next();
     if (global.field != null) {
       this._writeStaticField(global.field);
     }
     else {
       this.writer.writeln(('var ' + global.get$name() + ' = ' + global.exp.code + ';'));
     }
   }
 }
-WorldGenerator.prototype._orderValues = function(map) {
-  var values = map.getValues();
+WorldGenerator.prototype._orderValues = function(map0) {
+  var values = map0.getValues();
   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 (spans != 0) return spans;
   }
   if (x.get$span() == null) return 1;
   if (y.get$span() == null) return -1;
@@ skipping 10 matching lines @@
   this.genMethod(c);
   return factType;
 }
 // ********** Code for BlockScope **************
 function BlockScope(enclosingMethod, parent, reentrant) {
   this.enclosingMethod = enclosingMethod;
   this.parent = parent;
   this.reentrant = reentrant;
   this._vars = $map([]);
   // Initializers done
-  if (this.parent != null && $eq(this.parent.enclosingMethod, this.enclosingMethod)) {
+  if (this.get$isMethodScope()) {
+    this._closedOver = new HashSetImplementation$String();
+  }
+  else {
     this.reentrant = this.reentrant || this.parent.reentrant;
   }
 }
 BlockScope.prototype.get$parent = function() { return this.parent; };
 BlockScope.prototype.set$parent = function(value) { return this.parent = 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 (!s.get$isMethodScope()) s = s.get$parent();
+  return s;
+}
 BlockScope.prototype.lookup = function(name) {
   var ret = this._vars.$index(name);
   if ($ne(ret, null)) return ret;
   for (var s = this.parent;
    $ne(s, null); s = s.get$parent()) {
     ret = s._vars.$index(name);
     if ($ne(ret, null)) {
-      if (this.enclosingMethod.captures != null && s.reentrant && $ne(s.enclosingMethod, this.enclosingMethod)) {
-        this.enclosingMethod.captures.add(name);
+      if ($ne(s.enclosingMethod, this.enclosingMethod)) {
+        s.get$methodScope()._closedOver.add(ret.code);
+        if (this.enclosingMethod.captures != null && s.reentrant) {
+          this.enclosingMethod.captures.add(ret.code);
+        }
       }
       return ret;
     }
   }
 }
-BlockScope.prototype._isDefined = function(name) {
-  if (this._vars.containsKey(name)) return true;
-  if (this.parent != null) return this.parent._isDefined(name);
+BlockScope.prototype._isDefinedInParent = function(name) {
+  if (this.get$isMethodScope() && this._closedOver.contains(name)) return true;
+  for (var s = this.parent;
+   $ne(s, null); s = s.get$parent()) {
+    if (s._vars.containsKey(name)) return true;
+    if (s.get$isMethodScope() && s._closedOver.contains(name)) return true;
+  }
+  var type = this.enclosingMethod.method.declaringType;
+  if (type.resolveMember(name) != null) return true;
+  if (type.get$library().lookup(name, null) != null) return true;
   return false;
 }
 BlockScope.prototype.create = function(name, type, location) {
   var jsName = world.toJsIdentifier(name);
   if (this._vars.containsKey(name)) {
     if (location != null) {
       world.error(('duplicate name "' + name + '"'), location.span);
     }
     else {
       world.internalError(('conflict with temporary name "' + name + '"'));
     }
   }
-  if (this.parent != null) {
-    var index = 0;
-    while (this.parent._isDefined(jsName)) {
-      jsName = ('' + name + '' + index++ + '');
-    }
+  var index = 0;
+  while (this._isDefinedInParent(jsName)) {
+    jsName = ('' + name + '' + index++ + '');
   }
   var ret = new Value(type, jsName, false, false, false);
   this._vars.$setindex(name, ret);
   return ret;
 }
 BlockScope.prototype.declare = function(id) {
   var type = this.enclosingMethod.method.resolveType(id.type, false);
   return this.create(id.name.name, type, id);
 }
 BlockScope.prototype.getRethrow = function() {
@@ skipping 1329 matching lines @@
   return this.visitPostfixExpression($0, false);
 }
 ;
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
   // Initializers done
 }
 Arguments.Arguments$bare$factory = function(arity) {
-  var values = [];
+  var values0 = [];
   for (var i = 0;
    i < arity; i++) {
-    values.add(new Value(world.varType, ('\$' + i + ''), false, false, false));
+    values0.add(new Value(world.varType, ('\$' + i + ''), false, false, false));
   }
-  return new Arguments(null, values);
+  return new Arguments(null, values0);
 }
 Arguments.get$EMPTY = function() {
   if (Arguments._empty == null) {
     Arguments._empty = new Arguments(null, []);
   }
   return Arguments._empty;
 }
 Arguments.prototype.get$nameCount = function() {
   return this.get$length() - this.get$bareCount();
 }
@@ skipping 116 matching lines @@
   if (filename.startsWith('file:///')) return filename;
   if (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));
 }
 Library.prototype.addNative = function(fullname) {
   this.natives.add(world.reader.readFile(fullname));
 }
-Library.prototype.getOrAddFunctionType = function(name, func, inType) {
+Library.prototype.getOrAddFunctionType = function(name0, func, inType) {
   var def = new FunctionTypeDefinition(func, null, func.span);
-  var type = new DefinedType(name, this, def, false);
+  var type = new DefinedType(name0, this, def, false);
   type.addMethod('\$call', func);
   type.members.$index('\$call').resolve(inType);
   return type;
 }
-Library.prototype.addType = function(name, definition, isClass) {
-  if (this.types.containsKey(name)) {
-    var existingType = this.types.$index(name);
+Library.prototype.addType = function(name0, definition, isClass) {
+  if (this.types.containsKey(name0)) {
+    var existingType = this.types.$index(name0);
     if (this.get$isCore() && existingType.get$definition() == null) {
       existingType.setDefinition(definition);
     }
     else {
-      world.warning(('duplicate definition of ' + name + ''), definition.span);
+      world.warning(('duplicate definition of ' + name0 + ''), definition.span);
     }
   }
   else {
-    this.types.$setindex(name, new DefinedType(name, this, definition, isClass));
+    this.types.$setindex(name0, new DefinedType(name0, this, definition, isClass));
   }
-  return this.types.$index(name);
+  return this.types.$index(name0);
 }
 Library.prototype.findType = function(type) {
   var result = this.findTypeByName(type.name.name);
   if (result == null) return null;
   if (type.names != null) {
     if (type.names.length > 1) {
       return null;
     }
     if (!result.get$isTop()) {
       return null;
     }
     return result.get$library().findTypeByName(type.names.$index(0).get$name());
   }
   return result;
 }
-Library.prototype.findTypeByName = function(name) {
-  var ret = this.types.$index(name);
+Library.prototype.findTypeByName = function(name0) {
+  var ret = this.types.$index(name0);
   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);
+      newRet = imported.get$library().types.$index(name0);
     }
-    else if (imported.prefix == name) {
+    else if (imported.prefix == name0) {
       newRet = imported.get$library().topType;
     }
     if ($ne(newRet, null)) {
       if ($ne(ret, null) && $ne(ret, newRet)) {
-        world.error(('conflicting types for "' + name + '"'), ret.get$span());
-        world.error(('conflicting types for "' + name + '"'), newRet.get$span());
+        world.error(('conflicting types for "' + name0 + '"'), ret.get$span());
+        world.error(('conflicting types for "' + name0 + '"'), newRet.get$span());
       }
       else {
         ret = newRet;
       }
     }
   }
   return ret;
 }
-Library.prototype.lookup = function(name, span) {
-  var retType = this.findTypeByName(name);
+Library.prototype.lookup = function(name0, span0) {
+  var retType = this.findTypeByName(name0);
   var ret = null;
   if ($ne(retType, null)) {
     ret = retType.get$typeMember();
   }
-  var newRet = this.topType.getMember(name);
+  var newRet = this.topType.getMember(name0);
   if ($ne(newRet, null)) {
     if ($ne(ret, null) && $ne(ret, newRet)) {
-      world.error(('conflicting members for "' + name + '"'), span);
-      world.error(('conflicting members for "' + name + '"'), ret.get$span());
-      world.error(('conflicting members for "' + name + '"'), newRet.get$span());
+      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());
     }
     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);
+      newRet = imported.get$library().topType.getMember(name0);
       if ($ne(newRet, null)) {
         if ($ne(ret, null) && $ne(ret, newRet)) {
-          world.error(('conflicting members for "' + name + '"'), span);
-          world.error(('conflicting members for "' + name + '"'), ret.get$span());
-          world.error(('conflicting members for "' + name + '"'), newRet.get$span());
+          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());
         }
         else {
           ret = newRet;
         }
       }
     }
   }
   return ret;
 }
 Library.prototype.resolve = function() {
@@ skipping 194 matching lines @@
 function Member(name, declaringType) {
   this.name = name;
   this.declaringType = declaringType;
   this.isGenerated = false;
   // Initializers done
 }
 Member.prototype.get$name = function() { return this.name; };
 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.set$jsname = function(name0) {
+  return this._jsname = name0;
 }
 Member.prototype.get$library = function() {
   return this.declaringType.get$library();
 }
 Member.prototype.get$isPrivate = function() {
   return this.name.startsWith('_');
 }
 Member.prototype.get$isConstructor = function() {
   return false;
 }
@@ skipping 54 matching lines @@
 Member.prototype.get$generatedFactoryName = function() {
   var prefix = ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$');
   if (this.name == '') {
     return ('' + prefix + 'factory');
   }
   else {
     return ('' + prefix + '' + this.name + '\$factory');
   }
 }
 // ********** Code for TypeMember **************
-function TypeMember(type) {
-  this.type = type;
-  Member.call(this, type.name, type.library.topType);
+function TypeMember(type0) {
+  this.type = type0;
+  Member.call(this, type0.name, type0.library.topType);
   // Initializers done
 }
 $inherits(TypeMember, Member);
 TypeMember.prototype.get$span = function() {
   return this.type.definition.span;
 }
 TypeMember.prototype.get$isStatic = function() {
   return true;
 }
 TypeMember.prototype.get$returnType = function() {
@@ skipping 14 matching lines @@
 TypeMember.prototype.get_ = function(gen, node, target) {
   return new Value(this.type, this.type.get$jsname(), false, false, true);
 }
 TypeMember.prototype.set_ = function(gen, node, target, value) {
   world.error('can not set type', this.type.definition);
 }
 TypeMember.prototype.invoke = function(gen, node, target, args) {
   world.error('can not invoke type', this.type.definition);
 }
 // ********** Code for FieldMember **************
-function FieldMember(name, declaringType, definition, value) {
+function FieldMember(name0, declaringType0, definition, value) {
   this._providePropertySyntax = false
   this.definition = definition;
   this.value = value;
   this.isNative = false;
-  Member.call(this, name, declaringType);
+  Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(FieldMember, Member);
 FieldMember.prototype.get$definition = function() { return this.definition; };
 FieldMember.prototype.get$value = function() { return this.value; };
 FieldMember.prototype.get$isStatic = function() { return this.isStatic; };
 FieldMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 FieldMember.prototype.get$isNative = function() { return this.isNative; };
 FieldMember.prototype.set$isNative = function(value) { return this.isNative = value; };
 FieldMember.prototype.override = function(other) {
@@ skipping 102 matching lines @@
     var constTarget = (target instanceof GlobalValue) ? target.exp : target;
     if ((constTarget instanceof ConstObjectValue)) {
       return constTarget.fields.$index(this.name);
     }
     else if ($eq(constTarget.type, world.stringType) && this.name == 'length') {
       return new Value(this.type, ('' + constTarget.get$actualValue().length + ''), false, true, false);
     }
   }
   return new Value(this.type, ('' + target.code + '.' + this.get$jsname() + ''), false, true, false);
 }
-FieldMember.prototype.set_ = function(gen, node, target, value) {
+FieldMember.prototype.set_ = function(gen, node, target, value0) {
   var lhs = this.get_(gen, node, target);
-  value = value.convertTo(this.type, node);
-  return new Value(this.type, ('' + lhs.code + ' = ' + value.code + ''), false, true, false);
+  value0 = value0.convertTo(this.type, node);
+  return new Value(this.type, ('' + lhs.code + ' = ' + value0.code + ''), false, true, false);
 }
 // ********** Code for PropertyMember **************
-function PropertyMember(name, declaringType) {
+function PropertyMember(name0, declaringType0) {
   this._provideFieldSyntax = false
-  Member.call(this, name, declaringType);
+  Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(PropertyMember, Member);
 PropertyMember.prototype.get$span = function() {
   return this.getter != null ? this.getter.get$span() : null;
 }
 PropertyMember.prototype.get$canGet = function() {
   return this.getter != null;
 }
 PropertyMember.prototype.get$canSet = function() {
@@ skipping 47 matching lines @@
   }
   if (this.getter == null) this.getter = parentMember.getter;
   if (this.setter == null) this.setter = parentMember.setter;
 }
 PropertyMember.prototype.resolve = function(inType) {
   if (this.getter != null) this.getter.resolve(inType);
   if (this.setter != null) this.setter.resolve(inType);
   world._addMember(this);
 }
 // ********** Code for ConcreteMember **************
-function ConcreteMember(name, declaringType, baseMember) {
+function ConcreteMember(name0, declaringType0, baseMember) {
   this.baseMember = baseMember;
-  Member.call(this, name, declaringType);
+  Member.call(this, name0, declaringType0);
   // Initializers done
   this.parameters = [];
-  this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType);
+  this.returnType = this.baseMember.get$returnType().resolveTypeParams(declaringType0);
   var $list = this.baseMember.get$parameters();
   for (var $i = 0;$i < $list.length; $i++) {
     var p = $list.$index($i);
-    var newType = p.type.resolveTypeParams(declaringType);
+    var newType = p.type.resolveTypeParams(declaringType0);
     if ($ne(newType, p.type)) {
       this.parameters.add(p.copyWithNewType(newType));
     }
     else {
       this.parameters.add(p);
     }
   }
 }
 $inherits(ConcreteMember, Member);
 ConcreteMember.prototype.get$returnType = function() { return this.returnType; };
@@ skipping 78 matching lines @@
 ConcreteMember.prototype.invoke = function(gen, node, target, args) {
   var ret = this.baseMember.invoke(gen, node, target, args);
   var code = ret.code;
   if (this.get$isConstructor()) {
     code = code.replaceFirst(this.declaringType.genericType.get$jsname(), this.declaringType.get$jsname());
   }
   gen.genMethod(this);
   return new Value(this.returnType, code, false, true, false);
 }
 // ********** Code for MethodMember **************
-function MethodMember(name, declaringType, definition) {
+function MethodMember(name0, declaringType0, definition) {
   this.isStatic = false
   this.isAbstract = false
   this.isConst = false
   this.isFactory = false
   this.isLambda = false
   this._providePropertySyntax = false
   this._provideFieldSyntax = false
   this._provideOptionalParamInfo = false
   this.definition = definition;
-  Member.call(this, name, declaringType);
+  Member.call(this, name0, declaringType0);
   // Initializers done
 }
 $inherits(MethodMember, Member);
 MethodMember.prototype.get$definition = function() { return this.definition; };
 MethodMember.prototype.set$definition = function(value) { return this.definition = value; };
 MethodMember.prototype.get$returnType = function() { return this.returnType; };
 MethodMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 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; };
@@ skipping 63 matching lines @@
     if (!this.parameters.$index(bareCount).get$isOptional()) return false;
     for (var i = bareCount;
      i < args.get$length(); i++) {
       if (this.indexOfParameter(args.getName(i)) < 0) {
         return false;
       }
     }
   }
   return true;
 }
-MethodMember.prototype.indexOfParameter = function(name) {
+MethodMember.prototype.indexOfParameter = function(name0) {
   for (var i = 0;
    i < this.parameters.length; i++) {
     var p = this.parameters.$index(i);
-    if (p.get$isOptional() && $eq(p.get$name(), name)) {
+    if (p.get$isOptional() && $eq(p.get$name(), name0)) {
       return i;
     }
   }
   return -1;
 }
 MethodMember.prototype.resolveType = function(node, isRequired) {
   var type = this.declaringType.resolveType(node, isRequired);
   if (this.isStatic && type.get$hasTypeParams()) {
     world.error('using type parameter in static context', node.span);
   }
   return type;
 }
 MethodMember.prototype.get$prefersPropertySyntax = function() {
   return true;
 }
 MethodMember.prototype.get$requiresFieldSyntax = function() {
   return false;
 }
 MethodMember.prototype.provideFieldSyntax = function() {
   return this._provideFieldSyntax = true;
 }
 MethodMember.prototype.providePropertySyntax = function() {
   return this._providePropertySyntax = true;
 }
-MethodMember.prototype.set_ = function(gen, Node, target, value) {
+MethodMember.prototype.set_ = function(gen, Node0, target, value) {
   world.error('can not set method', this.definition);
 }
 MethodMember.prototype.get_ = function(gen, node, target) {
   gen.genMethod(this);
   this._provideOptionalParamInfo = true;
   if (this.isStatic) {
     var type = this.declaringType.get$isTop() ? '' : ('' + this.declaringType.get$jsname() + '.');
     return new Value(this.get$functionType(), ('' + type + '' + this.get$jsname() + ''), false, true, false);
   }
   this._providePropertySyntax = true;
@@ skipping 84 matching lines @@
         return this._argError(node, target, args, msg);
       }
       else {
         argsCode.add(this.isConst && value.get$isConst() ? value.canonicalCode : value.code);
       }
     }
     if (namedArgsUsed < args.get$nameCount()) {
       var seen = new HashSetImplementation$String();
       for (var i = bareCount;
        i < args.get$length(); i++) {
-        var name = args.getName(i);
-        if (seen.contains(name)) {
-          return this._argError(node, target, args, ('duplicate argument "' + name + '"'));
+        var name0 = args.getName(i);
+        if (seen.contains(name0)) {
+          return this._argError(node, target, args, ('duplicate argument "' + name0 + '"'));
         }
-        seen.add(name);
-        var p = this.indexOfParameter(name);
+        seen.add(name0);
+        var p = this.indexOfParameter(name0);
         if (p < 0) {
-          return this._argError(node, target, args, ('method does not have optional parameter "' + name + '"'));
+          return this._argError(node, target, args, ('method does not have optional parameter "' + name0 + '"'));
         }
         else if (p < bareCount) {
-          return this._argError(node, target, args, ('argument "' + name + '" passed as positional and named'));
+          return this._argError(node, target, args, ('argument "' + name0 + '" passed as positional and named'));
         }
       }
       world.internalError(('wrong named arguments calling ' + this.name + ''), node.span);
     }
     Arguments.removeTrailingNulls(argsCode);
   }
   var argsString = Strings.join(argsCode, ', ');
   if (this.get$isConstructor()) {
     return this._invokeConstructor(gen, node, target, args, argsString);
   }
@@ skipping 63 matching lines @@
           value = this.parameters.$index(i).get$value();
         }
       }
       fields.$setindex(fname, value);
     }
   }
   if (this.definition.initializers != null) {
     this.generator._pushBlock(false);
     for (var j = 0;
      j < this.definition.formals.length; j++) {
-      var name = this.definition.formals.$index(j).get$name().get$name();
+      var name0 = this.definition.formals.$index(j).get$name().get$name();
       var value = null;
       if (j < args.get$length()) {
         value = args.values.$index(j);
       }
       else {
         value = args.getValue(this.parameters.$index(j).get$name());
         if (value == null) {
           value = this.parameters.$index(j).get$value();
         }
       }
-      this.generator._scope._vars.$setindex(name, value);
+      this.generator._scope._vars.$setindex(name0, 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(init.get$arguments());
         var value = this.initDelegate.invoke(world.gen, node, target, delegateArgs);
         if ((init.target instanceof ThisExpression)) {
           return value;
         }
@@ skipping 623 matching lines @@
 function InterpStack(previous, quote, isMultiline) {
   this.previous = previous;
   this.quote = quote;
   this.isMultiline = isMultiline;
   this.depth = -1;
   // Initializers done
 }
 InterpStack.prototype.pop = function() {
   return this.previous;
 }
-InterpStack.push = function(stack, quote, isMultiline) {
-  var newStack = new InterpStack(stack, quote, isMultiline);
+InterpStack.push = function(stack, quote0, isMultiline0) {
+  var newStack = new InterpStack(stack, quote0, isMultiline0);
   if (stack != null) newStack.previous = stack;
   return newStack;
 }
 // ********** Code for TokenizerBase **************
 function TokenizerBase(_source, _skipWhitespace, _index) {
   this._source = _source;
   this._skipWhitespace = _skipWhitespace;
   this._lang_index = _index;
   // Initializers done
   this._text = this._source.get$text();
@@ skipping 1865 matching lines @@
         this._eatSemicolon();
         return new NativeStatement(nativeBody, this._makeSpan(start));
       }
       else {
         return this.functionBody(inExpression);
       }
     }
   }
   this._lang_error('Expected function body (neither { nor => found)');
 }
-lang_Parser.prototype.finishField = function(start, modifiers, type, name, value) {
+lang_Parser.prototype.finishField = function(start, modifiers, type0, name, value) {
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       values.add(this.expression());
     }
     else {
       values.add(null);
     }
   }
   this._eatSemicolon();
-  return new VariableDefinition(modifiers, type, names, values, this._makeSpan(start));
+  return new VariableDefinition(modifiers, type0, names, values, this._makeSpan(start));
 }
 lang_Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null;
       if (this._maybeEat(8/*TokenKind.COLON*/)) {
         inits = this.initializers();
       }
@@ skipping 34 matching lines @@
   var factoryToken = this._lang_next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add(this.identifier());
   }
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var name = null;
-  var type = null;
+  var type0 = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   else if (typeParams == null) {
     if (names.length > 1) {
       name = names.removeLast();
     }
     else {
       name = new lang_Identifier('', names.$index(0).get$span());
     }
   }
   else {
     name = new lang_Identifier('', names.$index(0).get$span());
   }
   if (names.length > 1) {
     this._lang_error('unsupported qualified name for factory', names.$index(0).get$span());
   }
-  type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
-  var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
+  type0 = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
+  var di = new DeclaredIdentifier(type0, name, this._makeSpan(start));
   return this.finishDefinition(start, [factoryToken], di);
 }
 lang_Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 87/*TokenKind.BREAK*/:
 
       return this.breakStatement();
 
     case 91/*TokenKind.CONTINUE*/:
 
@@ skipping 326 matching lines @@
   return new ContinueStatement(name, this._makeSpan(start));
 }
 lang_Parser.prototype.expression = function() {
   return this.infixExpression(0);
 }
 lang_Parser.prototype._makeType = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new NameTypeReference(false, expr.get$name(), null, expr.get$span());
   }
   else if ((expr instanceof DotExpression)) {
-    var type = this._makeType(expr.self);
-    if (type.names == null) {
-      type.names = [expr.get$name()];
+    var type0 = this._makeType(expr.self);
+    if (type0.names == null) {
+      type0.names = [expr.get$name()];
     }
     else {
-      type.names.add(expr.get$name());
+      type0.names.add(expr.get$name());
     }
-    type.span = expr.get$span();
-    return type;
+    type0.span = expr.get$span();
+    return type0;
   }
   else {
     this._lang_error('expected type reference');
     return null;
   }
 }
 lang_Parser.prototype.infixExpression = function(precedence) {
   return this.finishInfixExpression(this.unaryExpression(), precedence);
 }
-lang_Parser.prototype._finishDeclaredId = function(type) {
+lang_Parser.prototype._finishDeclaredId = function(type0) {
   var name = this.identifier();
-  return this.finishPostfixExpression(new DeclaredIdentifier(type, name, this._makeSpan(type.get$span().start)));
+  return this.finishPostfixExpression(new DeclaredIdentifier(type0, name, this._makeSpan(type0.get$span().start)));
 }
 lang_Parser.prototype._fixAsType = function(x) {
   if (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);
+    var type0 = new GenericTypeReference(base, [typeParam], 0, this._makeSpan(x.span.start));
+    return this._finishDeclaredId(type0);
   }
   else {
     var base = this._makeType(x.x);
     var paramBase = this._makeType(x.y);
     var firstParam = this.addTypeArguments(paramBase, 1);
-    var type;
+    var type0;
     if (firstParam.depth <= 0) {
-      type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
+      type0 = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
     else if (this._maybeEat(11/*TokenKind.COMMA*/)) {
-      type = this._finishTypeArguments(base, 0, [firstParam]);
+      type0 = this._finishTypeArguments(base, 0, [firstParam]);
     }
     else {
       this._eat(53/*TokenKind.GT*/);
-      type = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
+      type0 = new GenericTypeReference(base, [firstParam], 0, this._makeSpan(x.span.start));
     }
-    return this._finishDeclaredId(type);
+    return this._finishDeclaredId(type0);
   }
 }
 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 (this._isBin(x, 52/*TokenKind.LT*/)) {
           return this._fixAsType(x);
@@ skipping 305 matching lines @@
   else {
     if (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();
+lang_Parser.prototype._typeAsIdentifier = function(type0) {
+  return type0.get$name();
 }
 lang_Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case 15/*TokenKind.ELLIPSIS*/:
 
       this._eat(15/*TokenKind.ELLIPSIS*/);
       this._lang_error('rest no longer supported', this._previousToken);
       name = this.identifier().get$name();
@@ skipping 95 matching lines @@
 lang_Parser.parseHex = function(hex) {
   var result = 0;
   for (var i = 0;
    i < hex.length; i++) {
     var digit = lang_Parser._hexDigit(hex.charCodeAt(i));
     result = (result << 4) + digit;
   }
   return result;
 }
 lang_Parser.prototype.finishNewExpression = function(start, isConst) {
-  var type = this.type(0);
+  var type0 = this.type(0);
   var name = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
   var args = this.arguments();
-  return new lang_NewExpression(isConst, type, name, args, this._makeSpan(start));
+  return new lang_NewExpression(isConst, type0, name, args, this._makeSpan(start));
 }
-lang_Parser.prototype.finishListLiteral = function(start, isConst, type) {
+lang_Parser.prototype.finishListLiteral = function(start, isConst, type0) {
   if (this._maybeEat(56/*TokenKind.INDEX*/)) {
-    return new ListExpression(isConst, type, [], this._makeSpan(start));
+    return new ListExpression(isConst, type0, [], this._makeSpan(start));
   }
   var values = [];
   this._eat(4/*TokenKind.LBRACK*/);
   while (!this._maybeEat(5/*TokenKind.RBRACK*/)) {
     if (this.isPrematureEndOfFile()) break;
     values.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(5/*TokenKind.RBRACK*/);
       break;
     }
   }
-  return new ListExpression(isConst, type, values, this._makeSpan(start));
+  return new ListExpression(isConst, type0, values, this._makeSpan(start));
 }
-lang_Parser.prototype.finishMapLiteral = function(start, isConst, type) {
+lang_Parser.prototype.finishMapLiteral = function(start, isConst, type0) {
   var items = [];
   this._eat(6/*TokenKind.LBRACE*/);
   while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
     if (this.isPrematureEndOfFile()) break;
     items.add(this.expression());
     this._eat(8/*TokenKind.COLON*/);
     items.add(this.expression());
     if (!this._maybeEat(11/*TokenKind.COMMA*/)) {
       this._eat(7/*TokenKind.RBRACE*/);
       break;
     }
   }
-  return new MapExpression(isConst, type, items, this._makeSpan(start));
+  return new MapExpression(isConst, type0, items, this._makeSpan(start));
 }
 lang_Parser.prototype.finishTypedLiteral = function(start, isConst) {
   var span = this._makeSpan(start);
   var typeToBeNamedLater = new NameTypeReference(false, null, null, span);
   var genericType = this.addTypeArguments(typeToBeNamedLater, 0);
   if (this._peekKind(4/*TokenKind.LBRACK*/) || this._peekKind(56/*TokenKind.INDEX*/)) {
     return this.finishListLiteral(start, isConst, genericType);
   }
   else if (this._peekKind(6/*TokenKind.LBRACE*/)) {
     return this.finishMapLiteral(start, isConst, genericType);
@@ skipping 139 matching lines @@
   }
   else {
     return typeRef;
   }
 }
 lang_Parser.prototype.formalParameter = function(inOptionalBlock) {
   var start = this._peekToken.start;
   var isThis = false;
   var isRest = false;
   var di = this.declaredIdentifier(false);
-  var type = di.type;
+  var type0 = di.type;
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
     if (!inOptionalBlock) {
       this._lang_error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if (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());
+    var func = new FunctionDefinition(null, type0, name, formals, null, null, this._makeSpan(start));
+    type0 = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = new NullExpression(this._makeSpan(start));
   }
-  return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
+  return new FormalNode(isThis, isRest, type0, name, value, this._makeSpan(start));
 }
 lang_Parser.prototype.formalParameterList = function() {
   this._eat(2/*TokenKind.LPAREN*/);
   var formals = [];
   var inOptionalBlock = false;
   if (!this._maybeEat(3/*TokenKind.RPAREN*/)) {
     if (this._maybeEat(4/*TokenKind.LBRACK*/)) {
       inOptionalBlock = true;
     }
     formals.add(this.formalParameter(inOptionalBlock));
@@ skipping 14 matching lines @@
   return formals;
 }
 lang_Parser.prototype.identifier = function() {
   var tok = this._lang_next();
   if (!TokenKind.isIdentifier(tok.kind)) {
     this._lang_error(('expected identifier, but found ' + tok + ''), tok.get$span());
   }
   return new lang_Identifier(tok.get$text(), this._makeSpan(tok.start));
 }
 lang_Parser.prototype._makeFunction = function(expr, body) {
-  var name, type;
+  var name, type0;
   if ((expr instanceof CallExpression)) {
     if ((expr.target instanceof VarExpression)) {
       name = expr.target.get$name();
-      type = null;
+      type0 = null;
     }
     else if ((expr.target instanceof DeclaredIdentifier)) {
       name = expr.target.get$name();
-      type = expr.target.type;
+      type0 = expr.target.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 func = new FunctionDefinition(null, type, name, formals, null, body, span);
+    var func = new FunctionDefinition(null, type0, name, formals, null, body, span);
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._lang_error('expected function');
   }
 }
 lang_Parser.prototype._makeFormal = function(expr) {
   if ((expr instanceof VarExpression)) {
     return new FormalNode(false, false, null, expr.get$name(), null, expr.get$span());
   }
@@ skipping 16 matching lines @@
 }
 lang_Parser.prototype._makeFormalsFromList = function(expr) {
   if (expr.get$isConst()) {
     this._lang_error('expected formal, but found "const"', expr.get$span());
   }
   else if ($ne(expr.type, null)) {
     this._lang_error('expected formal, but found generic type arguments', expr.type.get$span());
   }
   return this._makeFormalsFromExpressions(expr.values, false);
 }
-lang_Parser.prototype._makeFormals = function(arguments) {
+lang_Parser.prototype._makeFormals = function(arguments0) {
   var expressions = [];
   for (var i = 0;
-   i < arguments.length; i++) {
-    var arg = arguments.$index(i);
+   i < arguments0.length; i++) {
+    var arg = arguments0.$index(i);
     if (arg.label != null) {
       this._lang_error('expected formal, but found ":"');
     }
     expressions.add(arg.get$value());
   }
   return this._makeFormalsFromExpressions(expressions, true);
 }
 lang_Parser.prototype._makeFormalsFromExpressions = function(expressions, allowOptional) {
   var formals = [];
   for (var i = 0;
    i < expressions.length; i++) {
     var formal = this._makeFormal(expressions.$index(i));
     if (formal == null) {
       var baseType = this._makeType(expressions.$index(i).x);
       var typeParams = [this._makeType(expressions.$index(i).y)];
       i++;
       while (i < expressions.length) {
         var expr = expressions.$index(i++);
         if (this._isBin(expr, 53/*TokenKind.GT*/)) {
           typeParams.add(this._makeType(expr.x));
-          var type = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
+          var type0 = new GenericTypeReference(baseType, typeParams, 0, this._makeSpan(baseType.get$span().start));
           var name = null;
           if ((expr.y instanceof VarExpression)) {
             var ve = expr.y;
             name = ve.name;
           }
           else {
             this._lang_error('expected formal', expr.get$span());
           }
-          formal = new FormalNode(false, false, type, name, null, this._makeSpan(expressions.$index(0).get$span().start));
+          formal = new FormalNode(false, false, type0, name, null, this._makeSpan(expressions.$index(0).get$span().start));
           break;
         }
         else {
           typeParams.add(this._makeType(expr));
         }
       }
       formals.add(formal);
     }
     else if (!!(formal && formal.is$List)) {
       formals.addAll(formal);
@@ skipping 29 matching lines @@
   }
 }
 // ********** Code for lang_Node **************
 function lang_Node(span) {
   this.span = span;
   // Initializers done
 }
 lang_Node.prototype.get$span = function() { return this.span; };
 lang_Node.prototype.set$span = function(value) { return this.span = value; };
 // ********** Code for Definition **************
-function Definition(span) {
-  lang_Statement.call(this, span);
+function Definition(span0) {
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(Definition, lang_Statement);
 Definition.prototype.get$typeParameters = function() {
   return null;
 }
 // ********** Code for lang_Statement **************
-function lang_Statement(span) {
-  lang_Node.call(this, span);
+function lang_Statement(span0) {
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(lang_Statement, lang_Node);
 // ********** Code for lang_Expression **************
-function lang_Expression(span) {
-  lang_Node.call(this, span);
+function lang_Expression(span0) {
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(lang_Expression, lang_Node);
 // ********** Code for TypeReference **************
-function TypeReference(span, type) {
+function TypeReference(span0, type) {
   this.type = type;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(TypeReference, lang_Node);
 TypeReference.prototype.visit = function(visitor) {
   return visitor.visitTypeReference(this);
 }
 // ********** Code for TreeOutput **************
 function TreeOutput() {}
 TreeOutput.prototype.write = function(s) {
   for (var i = 0;
@@ skipping 51 matching lines @@
         node.visit(this.printer);
       }
       else {
         this.writeln('null');
       }
     }
     this.depth -= 1;
   }
 }
 // ********** Code for DirectiveDefinition **************
-function DirectiveDefinition(name, arguments, span) {
+function DirectiveDefinition(name, arguments, span0) {
   this.name = name;
   this.arguments = arguments;
-  Definition.call(this, span);
+  Definition.call(this, span0);
   // Initializers done
 }
 $inherits(DirectiveDefinition, Definition);
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
 DirectiveDefinition.prototype.get$arguments = function() { return this.arguments; };
 DirectiveDefinition.prototype.set$arguments = function(value) { return this.arguments = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 // ********** Code for TypeDefinition **************
-function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span) {
+function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span0) {
   this.isClass = isClass;
   this.name = name;
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
   this.nativeType = nativeType;
   this.factoryType = factoryType;
   this.body = body;
-  Definition.call(this, span);
+  Definition.call(this, span0);
   // Initializers done
 }
 $inherits(TypeDefinition, Definition);
 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.visit = function(visitor) {
   return visitor.visitTypeDefinition(this);
 }
 // ********** Code for FunctionTypeDefinition **************
-function FunctionTypeDefinition(func, typeParameters, span) {
+function FunctionTypeDefinition(func, typeParameters, span0) {
   this.func = func;
   this.typeParameters = typeParameters;
-  Definition.call(this, span);
+  Definition.call(this, span0);
   // Initializers done
 }
 $inherits(FunctionTypeDefinition, Definition);
 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);
 }
 // ********** Code for VariableDefinition **************
-function VariableDefinition(modifiers, type, names, values, span) {
+function VariableDefinition(modifiers, type, names, values, span0) {
   this.modifiers = modifiers;
   this.type = type;
   this.names = names;
   this.values = values;
-  Definition.call(this, span);
+  Definition.call(this, span0);
   // Initializers done
 }
 $inherits(VariableDefinition, Definition);
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 // ********** Code for FunctionDefinition **************
-function FunctionDefinition(modifiers, returnType, name, formals, initializers, body, span) {
+function FunctionDefinition(modifiers, returnType, name, formals, initializers, body, span0) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
   this.initializers = initializers;
   this.body = body;
-  Definition.call(this, span);
+  Definition.call(this, span0);
   // Initializers done
 }
 $inherits(FunctionDefinition, Definition);
 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.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 // ********** Code for ReturnStatement **************
-function ReturnStatement(value, span) {
+function ReturnStatement(value, span0) {
   this.value = value;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(ReturnStatement, lang_Statement);
 ReturnStatement.prototype.get$value = function() { return this.value; };
 ReturnStatement.prototype.set$value = function(value) { return this.value = value; };
 ReturnStatement.prototype.visit = function(visitor) {
   return visitor.visitReturnStatement(this);
 }
 // ********** Code for ThrowStatement **************
-function ThrowStatement(value, span) {
+function ThrowStatement(value, span0) {
   this.value = value;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(ThrowStatement, lang_Statement);
 ThrowStatement.prototype.get$value = function() { return this.value; };
 ThrowStatement.prototype.set$value = function(value) { return this.value = value; };
 ThrowStatement.prototype.visit = function(visitor) {
   return visitor.visitThrowStatement(this);
 }
 // ********** Code for AssertStatement **************
-function AssertStatement(test, span) {
+function AssertStatement(test, span0) {
   this.test = test;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(AssertStatement, lang_Statement);
 AssertStatement.prototype.visit = function(visitor) {
   return visitor.visitAssertStatement(this);
 }
 // ********** Code for BreakStatement **************
-function BreakStatement(label, span) {
+function BreakStatement(label, span0) {
   this.label = label;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(BreakStatement, lang_Statement);
 BreakStatement.prototype.visit = function(visitor) {
   return visitor.visitBreakStatement(this);
 }
 // ********** Code for ContinueStatement **************
-function ContinueStatement(label, span) {
+function ContinueStatement(label, span0) {
   this.label = label;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(ContinueStatement, lang_Statement);
 ContinueStatement.prototype.visit = function(visitor) {
   return visitor.visitContinueStatement(this);
 }
 // ********** Code for IfStatement **************
-function IfStatement(test, trueBranch, falseBranch, span) {
+function IfStatement(test, trueBranch, falseBranch, span0) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(IfStatement, lang_Statement);
 IfStatement.prototype.visit = function(visitor) {
   return visitor.visitIfStatement(this);
 }
 // ********** Code for WhileStatement **************
-function WhileStatement(test, body, span) {
+function WhileStatement(test, body, span0) {
   this.test = test;
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(WhileStatement, lang_Statement);
 WhileStatement.prototype.visit = function(visitor) {
   return visitor.visitWhileStatement(this);
 }
 // ********** Code for DoStatement **************
-function DoStatement(body, test, span) {
+function DoStatement(body, test, span0) {
   this.body = body;
   this.test = test;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(DoStatement, lang_Statement);
 DoStatement.prototype.visit = function(visitor) {
   return visitor.visitDoStatement(this);
 }
 // ********** Code for ForStatement **************
-function ForStatement(init, test, step, body, span) {
+function ForStatement(init, test, step, body, span0) {
   this.init = init;
   this.test = test;
   this.step = step;
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(ForStatement, lang_Statement);
 ForStatement.prototype.visit = function(visitor) {
   return visitor.visitForStatement(this);
 }
 // ********** Code for ForInStatement **************
-function ForInStatement(item, list, body, span) {
+function ForInStatement(item, list, body, span0) {
   this.item = item;
   this.list = list;
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(ForInStatement, lang_Statement);
 ForInStatement.prototype.visit = function(visitor) {
   return visitor.visitForInStatement(this);
 }
 // ********** Code for TryStatement **************
-function TryStatement(body, catches, finallyBlock, span) {
+function TryStatement(body, catches, finallyBlock, span0) {
   this.body = body;
   this.catches = catches;
   this.finallyBlock = finallyBlock;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(TryStatement, lang_Statement);
 TryStatement.prototype.visit = function(visitor) {
   return visitor.visitTryStatement(this);
 }
 // ********** Code for SwitchStatement **************
-function SwitchStatement(test, cases, span) {
+function SwitchStatement(test, cases, span0) {
   this.test = test;
   this.cases = cases;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(SwitchStatement, lang_Statement);
 SwitchStatement.prototype.visit = function(visitor) {
   return visitor.visitSwitchStatement(this);
 }
 // ********** Code for BlockStatement **************
-function BlockStatement(body, span) {
+function BlockStatement(body, span0) {
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(BlockStatement, lang_Statement);
 BlockStatement.prototype.visit = function(visitor) {
   return visitor.visitBlockStatement(this);
 }
 // ********** Code for LabeledStatement **************
-function LabeledStatement(name, body, span) {
+function LabeledStatement(name, body, span0) {
   this.name = name;
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // 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.visit = function(visitor) {
   return visitor.visitLabeledStatement(this);
 }
 // ********** Code for lang_ExpressionStatement **************
-function lang_ExpressionStatement(body, span) {
+function lang_ExpressionStatement(body, span0) {
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(lang_ExpressionStatement, lang_Statement);
 lang_ExpressionStatement.prototype.visit = function(visitor) {
   return visitor.visitExpressionStatement(this);
 }
 // ********** Code for EmptyStatement **************
-function EmptyStatement(span) {
-  lang_Statement.call(this, span);
+function EmptyStatement(span0) {
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(EmptyStatement, lang_Statement);
 EmptyStatement.prototype.visit = function(visitor) {
   return visitor.visitEmptyStatement(this);
 }
 // ********** Code for DietStatement **************
-function DietStatement(span) {
-  lang_Statement.call(this, span);
+function DietStatement(span0) {
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(DietStatement, lang_Statement);
 DietStatement.prototype.visit = function(visitor) {
   return visitor.visitDietStatement(this);
 }
 // ********** Code for NativeStatement **************
-function NativeStatement(body, span) {
+function NativeStatement(body, span0) {
   this.body = body;
-  lang_Statement.call(this, span);
+  lang_Statement.call(this, span0);
   // Initializers done
 }
 $inherits(NativeStatement, lang_Statement);
 NativeStatement.prototype.visit = function(visitor) {
   return visitor.visitNativeStatement(this);
 }
 // ********** Code for LambdaExpression **************
-function LambdaExpression(func, span) {
+function LambdaExpression(func, span0) {
   this.func = func;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(LambdaExpression, lang_Expression);
 LambdaExpression.prototype.visit = function(visitor) {
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
-function CallExpression(target, arguments, span) {
+function CallExpression(target, arguments, span0) {
   this.target = target;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(CallExpression, lang_Expression);
 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);
 }
 // ********** Code for IndexExpression **************
-function IndexExpression(target, index, span) {
+function IndexExpression(target, index, span0) {
   this.target = target;
   this.index = index;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(IndexExpression, lang_Expression);
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
 }
 // ********** Code for BinaryExpression **************
-function BinaryExpression(op, x, y, span) {
+function BinaryExpression(op, x, y, span0) {
   this.op = op;
   this.x = x;
   this.y = y;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(BinaryExpression, lang_Expression);
 BinaryExpression.prototype.visit = function(visitor) {
   return visitor.visitBinaryExpression(this);
 }
 // ********** Code for UnaryExpression **************
-function UnaryExpression(op, self, span) {
+function UnaryExpression(op, self, span0) {
   this.op = op;
   this.self = self;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(UnaryExpression, lang_Expression);
 UnaryExpression.prototype.visit = function(visitor) {
   return visitor.visitUnaryExpression(this);
 }
 // ********** Code for PostfixExpression **************
-function PostfixExpression(body, op, span) {
+function PostfixExpression(body, op, span0) {
   this.body = body;
   this.op = op;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(PostfixExpression, lang_Expression);
 PostfixExpression.prototype.visit = function(visitor) {
   return visitor.visitPostfixExpression$1(this);
 }
 // ********** Code for lang_NewExpression **************
-function lang_NewExpression(isConst, type, name, arguments, span) {
+function lang_NewExpression(isConst, type, name, arguments, span0) {
   this.isConst = isConst;
   this.type = type;
   this.name = name;
   this.arguments = arguments;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // 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$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);
 }
 // ********** Code for ListExpression **************
-function ListExpression(isConst, type, values, span) {
+function ListExpression(isConst, type, values, span0) {
   this.isConst = isConst;
   this.type = type;
   this.values = values;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // 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.visit = function(visitor) {
   return visitor.visitListExpression(this);
 }
 // ********** Code for MapExpression **************
-function MapExpression(isConst, type, items, span) {
+function MapExpression(isConst, type, items, span0) {
   this.isConst = isConst;
   this.type = type;
   this.items = items;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // 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.visit = function(visitor) {
   return visitor.visitMapExpression(this);
 }
 // ********** Code for ConditionalExpression **************
-function ConditionalExpression(test, trueBranch, falseBranch, span) {
+function ConditionalExpression(test, trueBranch, falseBranch, span0) {
   this.test = test;
   this.trueBranch = trueBranch;
   this.falseBranch = falseBranch;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(ConditionalExpression, lang_Expression);
 ConditionalExpression.prototype.visit = function(visitor) {
   return visitor.visitConditionalExpression(this);
 }
 // ********** Code for IsExpression **************
-function IsExpression(isTrue, x, type, span) {
+function IsExpression(isTrue, x, type, span0) {
   this.isTrue = isTrue;
   this.x = x;
   this.type = type;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(IsExpression, lang_Expression);
 IsExpression.prototype.visit = function(visitor) {
   return visitor.visitIsExpression(this);
 }
 // ********** Code for ParenExpression **************
-function ParenExpression(body, span) {
+function ParenExpression(body, span0) {
   this.body = body;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(ParenExpression, lang_Expression);
 ParenExpression.prototype.visit = function(visitor) {
   return visitor.visitParenExpression(this);
 }
 // ********** Code for DotExpression **************
-function DotExpression(self, name, span) {
+function DotExpression(self, name, span0) {
   this.self = self;
   this.name = name;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(DotExpression, lang_Expression);
 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);
 }
 // ********** Code for VarExpression **************
-function VarExpression(name, span) {
+function VarExpression(name, span0) {
   this.name = name;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(VarExpression, lang_Expression);
 VarExpression.prototype.get$name = function() { return this.name; };
 VarExpression.prototype.set$name = function(value) { return this.name = value; };
 VarExpression.prototype.visit = function(visitor) {
   return visitor.visitVarExpression(this);
 }
 // ********** Code for ThisExpression **************
-function ThisExpression(span) {
-  lang_Expression.call(this, span);
+function ThisExpression(span0) {
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(ThisExpression, lang_Expression);
 ThisExpression.prototype.visit = function(visitor) {
   return visitor.visitThisExpression(this);
 }
 // ********** Code for SuperExpression **************
-function SuperExpression(span) {
-  lang_Expression.call(this, span);
+function SuperExpression(span0) {
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(SuperExpression, lang_Expression);
 SuperExpression.prototype.visit = function(visitor) {
   return visitor.visitSuperExpression(this);
 }
 // ********** Code for NullExpression **************
-function NullExpression(span) {
-  lang_Expression.call(this, span);
+function NullExpression(span0) {
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(NullExpression, lang_Expression);
 NullExpression.prototype.visit = function(visitor) {
   return visitor.visitNullExpression(this);
 }
 // ********** Code for LiteralExpression **************
-function LiteralExpression(value, type, text, span) {
+function LiteralExpression(value, type, text, span0) {
   this.value = value;
   this.type = type;
   this.text = text;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // 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$text = function() { return this.text; };
 LiteralExpression.prototype.set$text = function(value) { return this.text = value; };
 LiteralExpression.prototype.visit = function(visitor) {
   return visitor.visitLiteralExpression(this);
 }
 // ********** Code for NameTypeReference **************
-function NameTypeReference(isFinal, name, names, span) {
+function NameTypeReference(isFinal, name, names, span0) {
   this.isFinal = isFinal;
   this.name = name;
   this.names = names;
-  TypeReference.call(this, span);
+  TypeReference.call(this, span0);
   // Initializers done
 }
 $inherits(NameTypeReference, TypeReference);
 NameTypeReference.prototype.get$name = function() { return this.name; };
 NameTypeReference.prototype.set$name = function(value) { return this.name = value; };
 NameTypeReference.prototype.visit = function(visitor) {
   return visitor.visitNameTypeReference(this);
 }
 // ********** Code for GenericTypeReference **************
-function GenericTypeReference(baseType, typeArguments, depth, span) {
+function GenericTypeReference(baseType, typeArguments, depth, span0) {
   this.baseType = baseType;
   this.typeArguments = typeArguments;
   this.depth = depth;
-  TypeReference.call(this, span);
+  TypeReference.call(this, span0);
   // Initializers done
 }
 $inherits(GenericTypeReference, TypeReference);
 GenericTypeReference.prototype.visit = function(visitor) {
   return visitor.visitGenericTypeReference(this);
 }
 // ********** Code for FunctionTypeReference **************
-function FunctionTypeReference(isFinal, func, span) {
+function FunctionTypeReference(isFinal, func, span0) {
   this.isFinal = isFinal;
   this.func = func;
-  TypeReference.call(this, span);
+  TypeReference.call(this, span0);
   // Initializers done
 }
 $inherits(FunctionTypeReference, TypeReference);
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 // ********** Code for ArgumentNode **************
-function ArgumentNode(label, value, span) {
+function ArgumentNode(label, value, span0) {
   this.label = label;
   this.value = value;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(ArgumentNode, lang_Node);
 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);
 }
 // ********** Code for FormalNode **************
-function FormalNode(isThis, isRest, type, name, value, span) {
+function FormalNode(isThis, isRest, type, name, value, span0) {
   this.isThis = isThis;
   this.isRest = isRest;
   this.type = type;
   this.name = name;
   this.value = value;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(FormalNode, lang_Node);
 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);
 }
 // ********** Code for CatchNode **************
-function CatchNode(exception, trace, body, span) {
+function CatchNode(exception, trace, body, span0) {
   this.exception = exception;
   this.trace = trace;
   this.body = body;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // 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.visit = function(visitor) {
   return visitor.visitCatchNode(this);
 }
 // ********** Code for CaseNode **************
-function CaseNode(label, cases, statements, span) {
+function CaseNode(label, cases, statements, span0) {
   this.label = label;
   this.cases = cases;
   this.statements = statements;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(CaseNode, lang_Node);
 CaseNode.prototype.visit = function(visitor) {
   return visitor.visitCaseNode(this);
 }
 // ********** Code for TypeParameter **************
-function TypeParameter(name, extendsType, span) {
+function TypeParameter(name, extendsType, span0) {
   this.name = name;
   this.extendsType = extendsType;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // 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.visit = function(visitor) {
   return visitor.visitTypeParameter(this);
 }
 // ********** Code for lang_Identifier **************
-function lang_Identifier(name, span) {
+function lang_Identifier(name, span0) {
   this.name = name;
-  lang_Node.call(this, span);
+  lang_Node.call(this, span0);
   // Initializers done
 }
 $inherits(lang_Identifier, lang_Node);
 lang_Identifier.prototype.get$name = function() { return this.name; };
 lang_Identifier.prototype.set$name = function(value) { return this.name = value; };
 lang_Identifier.prototype.visit = function(visitor) {
   return visitor.visitIdentifier(this);
 }
 // ********** Code for DeclaredIdentifier **************
-function DeclaredIdentifier(type, name, span) {
+function DeclaredIdentifier(type, name, span0) {
   this.type = type;
   this.name = name;
-  lang_Expression.call(this, span);
+  lang_Expression.call(this, span0);
   // Initializers done
 }
 $inherits(DeclaredIdentifier, lang_Expression);
 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);
 }
 // ********** Code for TreePrinter **************
 function TreePrinter() {}
@@ skipping 270 matching lines @@
 lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
   if (this._typeMember == null) {
     this._typeMember = new TypeMember(this);
   }
   return this._typeMember;
 }
-lang_Type.prototype.getMember = function(name) {
+lang_Type.prototype.getMember = function(name0) {
   return null;
 }
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
 lang_Type.prototype.get$isTop = function() {
   return false;
 }
 lang_Type.prototype.get$isObject = function() {
   return false;
@@ skipping 39 matching lines @@
 }
 lang_Type.prototype.get$hasTypeParams = function() {
   return false;
 }
 lang_Type.prototype.get$typeofName = function() {
   return null;
 }
 lang_Type.prototype.get$jsname = function() {
   return this._jsname == null ? this.name : this._jsname;
 }
-lang_Type.prototype.set$jsname = function(name) {
-  return this._jsname = name;
+lang_Type.prototype.set$jsname = function(name0) {
+  return this._jsname = name0;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
 lang_Type.prototype.ensureAssignableFrom = function(other, node, isRequired) {
   if (isRequired && !this.isAssignableFrom(other)) {
     var msg = isRequired ? world.get$error() : world.get$warning();
     msg.call$2(('type ' + this.name + ' is not assignable from ' + other.name + ''), node.span);
   }
 }
 lang_Type.prototype.needsVarCall = function(args) {
   if (this.get$isVarOrFunction()) {
     return true;
   }
   var call = this.getCallMethod();
   if ($ne(call, null)) {
     if (args.get$length() != call.get$parameters().length || !call.namesInOrder(args)) {
       return true;
     }
   }
   return false;
 }
 lang_Type.union = function(x, y) {
   if ($eq(x, y)) return x;
   if (x.get$isNum() && y.get$isNum()) return world.numType;
   if (x.get$isString() && y.get$isString()) return world.stringType;
   return world.varType;
 }
 // ********** Code for ParameterType **************
-function ParameterType(name, typeParameter) {
+function ParameterType(name0, typeParameter) {
   this.typeParameter = typeParameter;
-  lang_Type.call(this, name);
+  lang_Type.call(this, name0);
   // Initializers done
 }
 $inherits(ParameterType, lang_Type);
 ParameterType.prototype.get$isClass = function() {
   return false;
 }
 ParameterType.prototype.get$library = function() {
   return null;
 }
 ParameterType.prototype.get$span = function() {
@@ skipping 19 matching lines @@
 }
 ParameterType.prototype.resolve = function(inType) {
   if (this.typeParameter.extendsType != null) {
     this.extendsType = inType.resolveType(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = world.objectType;
   }
 }
 // ********** Code for ConcreteType **************
-function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
+function ConcreteType(name0, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
-  lang_Type.call(this, name);
+  lang_Type.call(this, name0);
   // Initializers done
 }
 $inherits(ConcreteType, lang_Type);
 ConcreteType.prototype.get$isList = function() {
   return this.genericType.get$isList();
 }
 ConcreteType.prototype.get$isClass = function() {
   return this.genericType.get$isClass();
 }
 ConcreteType.prototype.get$library = function() {
@@ skipping 55 matching lines @@
 }
 ConcreteType.prototype.markUsed = function() {
   this.genericType.markUsed();
 }
 ConcreteType.prototype.isParentOf = function(child) {
   if (this.genericType.isParentOf(child)) return true;
   if ((child instanceof ConcreteType)) {
     if ($eq(child.genericType, this.genericType)) {
       var $list = this.typeArguments.getKeys();
       for (var $i = this.typeArguments.getKeys().iterator(); $i.hasNext(); ) {
-        var name = $i.next();
-        var myType = this.typeArguments.$index(name);
-        var childType = child.typeArguments.$index(name);
+        var name0 = $i.next();
+        var myType = this.typeArguments.$index(name0);
+        var childType = child.typeArguments.$index(name0);
         if (!myType.isParentOf(childType)) return false;
       }
       return true;
     }
     if (this.genericType.isParentOf(child.genericType)) {
       return true;
     }
   }
   return false;
 }
@@ skipping 48 matching lines @@
   return ret;
 }
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
   return ret;
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 // ********** Code for DefinedType **************
-function DefinedType(name, library, definition, isClass) {
+function DefinedType(name0, library, definition0, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = [];
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
   this._resolvedMembers = $map([]);
-  lang_Type.call(this, name);
+  lang_Type.call(this, name0);
   // Initializers done
-  this.setDefinition(definition);
+  this.setDefinition(definition0);
 }
 $inherits(DefinedType, lang_Type);
 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$interfaces = function() { return this.interfaces; };
 DefinedType.prototype.set$interfaces = function(value) { return this.interfaces = value; };
@@ skipping 64 matching lines @@
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
   if (this.parent != null) this.parent.markUsed();
 }
 DefinedType.prototype._resolveInterfaces = function(types) {
   if (types == null) return [];
-  var interfaces = [];
+  var interfaces0 = [];
   for (var $i = 0;$i < types.length; $i++) {
     var type = types.$index($i);
     var resolvedInterface = this.resolveType(type, true);
     if (resolvedInterface.get$isClosed() && !(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);
+    interfaces0.add(resolvedInterface);
   }
-  return interfaces;
+  return interfaces0;
 }
 DefinedType.prototype.isParentOf = function(child) {
   return this.get$isVar() || this.get$isObject() || $eq(child, this) || this.get$subtypes().some((function (s) {
     return $eq(s, child);
   })
   );
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
   var present = this.directSubtypes.some((function (t) {
     return $eq(t, type);
@@ skipping 86 matching lines @@
   var $list0 = this.members.getValues();
   for (var $i = this.members.getValues().iterator(); $i.hasNext(); ) {
     var m = $i.next();
     m.resolve(this);
   }
   this.factories.forEach((function (f) {
     return f.resolve($this);
   })
   );
 }
-DefinedType.prototype.addMethod = function(methodName, definition) {
-  if (methodName == null) methodName = definition.name.name;
-  var method = new MethodMember(methodName, this, definition);
+DefinedType.prototype.addMethod = function(methodName, definition0) {
+  if (methodName == null) methodName = definition0.name.name;
+  var method = new MethodMember(methodName, this, definition0);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
-      world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition.span);
+      world.error(('duplicate constructor definition of ' + method.get$name() + ''), definition0.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
   }
-  if (definition.modifiers != null && definition.modifiers.length == 1 && definition.modifiers.$index(0).kind == 74/*TokenKind.FACTORY*/) {
+  if (definition0.modifiers != null && definition0.modifiers.length == 1 && definition0.modifiers.$index(0).kind == 74/*TokenKind.FACTORY*/) {
     if (this.factories.getFactory(method.get$constructorName(), method.get$name()) != null) {
-      world.error(('duplicate factory definition of ' + method.get$name() + ''), definition.span);
+      world.error(('duplicate factory definition of ' + method.get$name() + ''), definition0.span);
       return;
     }
     this.factories.addFactory(method.get$constructorName(), method.get$name(), method);
     return;
   }
   if (methodName.startsWith('get\$') || methodName.startsWith('set\$')) {
     var propName = methodName.substring(4);
     var prop = this.members.$index(propName);
     if (prop == null) {
       prop = new PropertyMember(propName, this);
       this.members.$setindex(propName, prop);
     }
     if (!(prop instanceof PropertyMember)) {
-      world.error(('property conflicts with field name: ' + propName + ''), definition.span);
+      world.error(('property conflicts with field name: ' + propName + ''), definition0.span);
       return;
     }
     if (methodName[0] == 'g') {
       if (prop.getter != null) {
-        world.error(('duplicate getter definition for ' + propName + ''), definition.span);
+        world.error(('duplicate getter definition for ' + propName + ''), definition0.span);
       }
       prop.getter = method;
     }
     else {
       if (prop.setter != null) {
-        world.error(('duplicate setter definition for ' + propName + ''), definition.span);
+        world.error(('duplicate setter definition for ' + propName + ''), definition0.span);
       }
       prop.setter = method;
     }
     return;
   }
   if (this.members.containsKey(methodName)) {
-    world.error(('duplicate method definition of ' + method.get$name() + ''), definition.span);
+    world.error(('duplicate method definition of ' + method.get$name() + ''), definition0.span);
     return;
   }
   this.members.$setindex(methodName, method);
 }
-DefinedType.prototype.addField = function(definition) {
+DefinedType.prototype.addField = function(definition0) {
   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);
+   i < definition0.names.length; i++) {
+    var name0 = definition0.names.$index(i).get$name();
+    if (this.members.containsKey(name0)) {
+      world.error(('duplicate field definition of ' + name0 + ''), definition0.span);
       return;
     }
     var value = null;
-    if (definition.values != null) {
-      value = definition.values.$index(i);
+    if (definition0.values != null) {
+      value = definition0.values.$index(i);
     }
-    var field = new FieldMember(name, this, definition, value);
-    this.members.$setindex(name, field);
+    var field = new FieldMember(name0, this, definition0, value);
+    this.members.$setindex(name0, field);
     if (this.isNativeType) {
       field.isNative = true;
     }
   }
 }
 DefinedType.prototype.getFactory = function(type, constructorName) {
   var ret = this.factories.getFactory(type.name, constructorName);
   if ($ne(ret, null)) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($ne(ret, null)) return ret;
   ret = this.constructors.$index(constructorName);
   if ($ne(ret, null)) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($ne(ret, null)) {
     if (this.factory_ != null) {
       return this.factory_.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if ($ne(ret, null)) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
-DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
-  if (name == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0) {
-    var span = this.definition.span;
+DefinedType.prototype._tryCreateDefaultConstructor = function(name0) {
+  if (name0 == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0) {
+    var span0 = this.definition.span;
     var inits = null, body = null;
     if (this.isNativeType) {
-      body = new NativeStatement(null, span);
+      body = new NativeStatement(null, span0);
       inits = null;
     }
     else {
       body = null;
-      inits = [new CallExpression(new SuperExpression(span), [], span)];
+      inits = [new CallExpression(new SuperExpression(span0), [], span0)];
     }
-    var c = new FunctionDefinition(null, null, this.definition.get$name(), [], inits, body, span);
+    var c = new FunctionDefinition(null, null, this.definition.get$name(), [], inits, body, span0);
     this.addMethod(null, c);
     this.constructors.$index('').resolve(this);
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var member = this.members.$index(memberName);
   if (member != null) {
     var parentMember = this.getMemberInParents(memberName);
@@ skipping 93 matching lines @@
     return type.name.name + '.' + Strings.join(names, '.');
   }
   else {
     return type.name.name;
   }
 }
 DefinedType.prototype.resolveType = function(node, isRequired) {
   if (node == null) return world.varType;
   if (node.type != null) return node.type;
   if ((node instanceof NameTypeReference)) {
-    var name;
+    var name0;
     if (node.names != null) {
-      name = node.names.last().get$name();
+      name0 = node.names.last().get$name();
     }
     else {
-      name = node.get$name().get$name();
+      name0 = node.get$name().get$name();
     }
     if (this.typeParameters != null) {
       var $list = this.typeParameters;
       for (var $i = 0;$i < $list.length; $i++) {
         var tp = $list.$index($i);
-        if ($eq(tp.get$name(), name)) {
+        if ($eq(tp.get$name(), name0)) {
           node.type = tp;
         }
       }
     }
     if (node.type == null) {
       node.type = this.library.findType(node);
     }
     if (node.type == null) {
       var message = ('can not find type ' + DefinedType._getDottedName(node) + '');
       if (isRequired) {
@@ skipping 22 matching lines @@
       var extendsType = baseType.get$typeParameters().$index(i).extendsType;
       var typeArg = this.resolveType(node.typeArguments.$index(i), isRequired);
       typeArgs.add(typeArg);
       if ($ne(extendsType, null) && !(typeArg instanceof ParameterType)) {
         extendsType.ensureAssignableFrom(typeArg, node.typeArguments.$index(i), isRequired);
       }
     }
     node.type = baseType.getOrMakeConcreteType(typeArgs);
   }
   else if ((node instanceof FunctionTypeReference)) {
-    var name = '';
-    if (node.func.name != null) name = node.func.name.name;
-    node.type = this.library.getOrAddFunctionType(name, node.func, this);
+    var name0 = '';
+    if (node.func.name != null) name0 = node.func.name.name;
+    node.type = this.library.getOrAddFunctionType(name0, node.func, this);
   }
   else {
     world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
@@ skipping 45 matching lines @@
   if (other.get$interfaces() != null) {
     var $list = other.get$interfaces();
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       if (this._interfaceIsAssignableFrom(i)) return true;
     }
   }
   return false;
 }
 DefinedType.prototype.getCallStub = function(args) {
-  var name = _getCallStubName('call', args);
+  var name0 = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
-  var stub = this.varStubs.$index(name);
+  var stub = this.varStubs.$index(name0);
   if (stub == null) {
-    stub = new VarFunctionStub(name, args);
-    this.varStubs.$setindex(name, stub);
+    stub = new VarFunctionStub(name0, args);
+    this.varStubs.$setindex(name0, stub);
   }
   return stub;
 }
 // ********** Code for Value **************
 function Value(type, code, isSuper, needsTemp, isType) {
   this.type = type;
   this.code = code;
   this.isSuper = isSuper;
   this.needsTemp = needsTemp;
   this.isType = isType;
@@ skipping 133 matching lines @@
   if (name == '\$index' || name == '\$setindex') {
     return new Value(returnType, ('' + this.code + '.' + name + '(' + argsString + ')'), false, true, false);
   }
   else {
     if (argsString.length > 0) argsString = (', ' + argsString + '');
     return new Value(returnType, ('' + name + '(' + this.code + '' + argsString + ')'), false, true, false);
   }
 }
 // ********** Code for EvaluatedValue **************
 function EvaluatedValue() {}
-EvaluatedValue._internal$ctor = function(type, actualValue, canonicalCode, original, code) {
+EvaluatedValue._internal$ctor = function(type0, actualValue, canonicalCode, original, code0) {
   this.actualValue = actualValue;
   this.canonicalCode = canonicalCode;
   this.original = original;
-  Value.call(this, type, code, false, false, false);
+  Value.call(this, type0, code0, false, false, false);
   // Initializers done
 }
 EvaluatedValue._internal$ctor.prototype = EvaluatedValue.prototype;
 $inherits(EvaluatedValue, Value);
-EvaluatedValue.EvaluatedValue$factory = function(type, actualValue, canonicalCode, original) {
-  return new EvaluatedValue._internal$ctor(type, actualValue, canonicalCode, original, EvaluatedValue.codeWithComments(canonicalCode, original));
+EvaluatedValue.EvaluatedValue$factory = function(type0, actualValue0, canonicalCode0, original0) {
+  return new EvaluatedValue._internal$ctor(type0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 EvaluatedValue.prototype.get$actualValue = function() { return this.actualValue; };
 EvaluatedValue.prototype.set$actualValue = function(value) { return this.actualValue = value; };
 EvaluatedValue.prototype.get$isConst = function() {
   return true;
 }
-EvaluatedValue.codeWithComments = function(canonicalCode, original) {
-  return (original != null && original.get$text() != canonicalCode) ? ('' + canonicalCode + '/*' + original.get$text() + '*/') : canonicalCode;
+EvaluatedValue.codeWithComments = function(canonicalCode0, original0) {
+  return (original0 != null && original0.get$text() != canonicalCode0) ? ('' + canonicalCode0 + '/*' + original0.get$text() + '*/') : canonicalCode0;
 }
 // ********** Code for ConstListValue **************
 function ConstListValue() {}
-ConstListValue._internal$ctor = function(type, values, actualValue, canonicalCode, original, code) {
+ConstListValue._internal$ctor = function(type0, values, actualValue0, canonicalCode0, original0, code0) {
   this.values = values;
-  EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, original, code);
+  EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstListValue._internal$ctor.prototype = ConstListValue.prototype;
 $inherits(ConstListValue, EvaluatedValue);
-ConstListValue.ConstListValue$factory = function(type, values, actualValue, canonicalCode, original) {
-  return new ConstListValue._internal$ctor(type, values, actualValue, canonicalCode, original, EvaluatedValue.codeWithComments(canonicalCode, original));
+ConstListValue.ConstListValue$factory = function(type0, values0, actualValue0, canonicalCode0, original0) {
+  return new ConstListValue._internal$ctor(type0, values0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for ConstMapValue **************
 function ConstMapValue() {}
-ConstMapValue._internal$ctor = function(type, values, actualValue, canonicalCode, original, code) {
+ConstMapValue._internal$ctor = function(type0, values, actualValue0, canonicalCode0, original0, code0) {
   this.values = values;
-  EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, original, code);
+  EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstMapValue._internal$ctor.prototype = ConstMapValue.prototype;
 $inherits(ConstMapValue, EvaluatedValue);
-ConstMapValue.ConstMapValue$factory = function(type, keyValuePairs, actualValue, canonicalCode, original) {
-  var values = new HashMapImplementation$String$EvaluatedValue();
+ConstMapValue.ConstMapValue$factory = function(type0, keyValuePairs, actualValue0, canonicalCode0, original0) {
+  var values0 = new HashMapImplementation$String$EvaluatedValue();
   for (var i = 0;
    i < keyValuePairs.length; i += 2) {
-    values.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
+    values0.$setindex(keyValuePairs.$index(i).get$actualValue(), keyValuePairs.$index(i + 1));
   }
-  return new ConstMapValue._internal$ctor(type, values, actualValue, canonicalCode, original, EvaluatedValue.codeWithComments(canonicalCode, original));
+  return new ConstMapValue._internal$ctor(type0, values0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for ConstObjectValue **************
 function ConstObjectValue() {}
-ConstObjectValue._internal$ctor = function(type, fields, actualValue, canonicalCode, original, code) {
+ConstObjectValue._internal$ctor = function(type0, fields, actualValue0, canonicalCode0, original0, code0) {
   this.fields = fields;
-  EvaluatedValue._internal$ctor.call(this, type, actualValue, canonicalCode, original, code);
+  EvaluatedValue._internal$ctor.call(this, type0, actualValue0, canonicalCode0, original0, code0);
   // Initializers done
 }
 ConstObjectValue._internal$ctor.prototype = ConstObjectValue.prototype;
 $inherits(ConstObjectValue, EvaluatedValue);
-ConstObjectValue.ConstObjectValue$factory = function(type, fields, canonicalCode, original) {
+ConstObjectValue.ConstObjectValue$factory = function(type0, fields0, canonicalCode0, original0) {
   var fieldValues = [];
-  var $list = fields.getKeys();
-  for (var $i = fields.getKeys().iterator(); $i.hasNext(); ) {
+  var $list = fields0.getKeys();
+  for (var $i = fields0.getKeys().iterator(); $i.hasNext(); ) {
     var f = $i.next();
-    fieldValues.add(('' + f + ' = ' + fields.$index(f).get$actualValue() + ''));
+    fieldValues.add(('' + f + ' = ' + fields0.$index(f).get$actualValue() + ''));
   }
   fieldValues.sort((function (a, b) {
     return a.compareTo(b);
   })
   );
-  var actualValue = ('const ' + type.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
-  return new ConstObjectValue._internal$ctor(type, fields, actualValue, canonicalCode, original, EvaluatedValue.codeWithComments(canonicalCode, original));
+  var actualValue0 = ('const ' + type0.get$jsname() + ' [') + Strings.join(fieldValues, ',') + ']';
+  return new ConstObjectValue._internal$ctor(type0, fields0, actualValue0, canonicalCode0, original0, EvaluatedValue.codeWithComments(canonicalCode0, original0));
 }
 // ********** Code for GlobalValue **************
-function GlobalValue(type, code, isConst, field, name, exp, canonicalCode, original, dependencies) {
+function GlobalValue(type0, code0, isConst0, field, name, exp, canonicalCode, original, dependencies) {
   this.field = field;
   this.name = name;
   this.exp = exp;
   this.canonicalCode = canonicalCode;
   this.original = original;
   this.dependencies = dependencies;
-  Value.call(this, type, code, false, !isConst, false);
+  Value.call(this, type0, code0, false, !isConst0, false);
   // Initializers done
 }
 $inherits(GlobalValue, Value);
-GlobalValue.GlobalValue$fromStatic$factory = function(field, exp, dependencies) {
-  var code = (exp.get$isConst() ? exp.canonicalCode : exp.code);
-  var codeWithComment = ('' + code + '/*' + field.declaringType.name + '.' + field.get$name() + '*/');
-  return new GlobalValue(exp.type, codeWithComment, field.isFinal, field, null, exp, code, null, dependencies.filter((function (d) {
+GlobalValue.GlobalValue$fromStatic$factory = function(field0, exp0, dependencies0) {
+  var code0 = (exp0.get$isConst() ? exp0.canonicalCode : exp0.code);
+  var codeWithComment = ('' + code0 + '/*' + field0.declaringType.name + '.' + field0.get$name() + '*/');
+  return new GlobalValue(exp0.type, codeWithComment, field0.isFinal, field0, null, exp0, code0, null, dependencies0.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
-GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp, dependencies) {
-  var name = ("const\$" + uniqueId + "");
-  var codeWithComment = ("" + name + "/*" + exp.original.get$text() + "*/");
-  return new GlobalValue(exp.type, codeWithComment, true, null, name, exp, name, exp.original, dependencies.filter((function (d) {
+GlobalValue.GlobalValue$fromConst$factory = function(uniqueId, exp0, dependencies0) {
+  var name0 = ("const\$" + uniqueId + "");
+  var codeWithComment = ("" + name0 + "/*" + exp0.original.get$text() + "*/");
+  return new GlobalValue(exp0.type, codeWithComment, true, null, name0, exp0, name0, exp0.original, dependencies0.filter((function (d) {
     return (d instanceof GlobalValue);
   })
   ));
 }
 GlobalValue.prototype.get$name = function() { return this.name; };
 GlobalValue.prototype.set$name = function(value) { return this.name = value; };
 GlobalValue.prototype.get$isConst = function() {
   return this.exp.get$isConst() && (this.field == null || this.field.isFinal);
 }
 GlobalValue.prototype.get$actualValue = function() {
@@ skipping 538 matching lines @@
 VarMethodStub.prototype.generateBody = function(code) {
   if (this._useDirectCall(this.member, this.args)) {
     code.write(('' + this.get$typeName() + '.prototype.' + this.member.get$jsname() + ''));
   }
   else {
     code.enterBlock(('function(' + this.args.getCode() + ') {'));
     code.writeln(('return ' + this.body.code + ';'));
     code.exitBlock('}');
   }
 }
-VarMethodStub.prototype._useDirectCall = function(member, args) {
-  if ((member instanceof MethodMember) && $ne(member.declaringType.get$library(), world.get$dom())) {
-    var method = member;
+VarMethodStub.prototype._useDirectCall = function(member0, args0) {
+  if ((member0 instanceof MethodMember) && $ne(member0.declaringType.get$library(), world.get$dom())) {
+    var method = member0;
     method.genParameterValues();
-    for (var i = args.get$length();
+    for (var i = args0.get$length();
      i < method.parameters.length; i++) {
       if (method.parameters.$index(i).get$value().code != 'null') {
         return false;
       }
     }
-    return method.namesInOrder(args);
+    return method.namesInOrder(args0);
   }
   else {
     return false;
   }
 }
 // ********** Code for VarMethodSet **************
 function VarMethodSet(name, members, callArgs, returnType) {
   this.name = name;
   this.members = members;
   this.returnType = returnType;
   this.args = callArgs.toCallStubArgs();
   // Initializers done
 }
 $inherits(VarMethodSet, VarMember);
 VarMethodSet.prototype.get$name = function() { return this.name; };
 VarMethodSet.prototype.get$returnType = function() { return this.returnType; };
 VarMethodSet.prototype.get$baseName = function() {
   return this.members.$index(0).get$name();
 }
-VarMethodSet.prototype.invoke = function(node, target, args) {
+VarMethodSet.prototype.invoke = function(node, target, args0) {
   this._invokeMembers(node);
-  return VarMember.prototype.invoke.call(this, node, target, args);
+  return VarMember.prototype.invoke.call(this, node, target, args0);
 }
 VarMethodSet.prototype._invokeMembers = function(node) {
   if (this._fallbackStubs != null) return;
   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', false, true, false);
     var result = member.invoke(world.gen, node, target, this.args);
     var stub = new VarMethodStub(this.name, member, this.args, result);
@@ skipping 48 matching lines @@
   var i = source.iterator();
   var current = initialValue;
   if (current == null && i.hasNext()) {
     current = i.next();
   }
   while (i.hasNext()) {
     current = callback.call$2(current, i.next());
   }
   return current;
 }
-function orderValuesByKeys(map) {
-  var keys = map.getKeys();
+function orderValuesByKeys(map0) {
+  var keys = map0.getKeys();
   keys.sort((function (x, y) {
     return x.compareTo(y);
   })
   );
   var values = [];
   for (var $i = keys.iterator(); $i.hasNext(); ) {
     var k = $i.next();
-    values.add(map.$index(k));
+    values.add(map0.$index(k));
   }
   return values;
 }
 function isMultilineString(text) {
   return text.startsWith('"""') || text.startsWith("'''");
 }
 function isRawMultilineString(text) {
   return text.startsWith('@"""') || text.startsWith("@'''");
 }
 function parseStringLiteral(lit) {
@@ skipping 221 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();