fixes #131, use before define from variables to classes

lib/src/codegen/js_names.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_names;
 
 import 'dart:collection';
 import 'package:dev_compiler/src/js/js_ast.dart';
 
 /// Unique instance for temporary variables. Will be renamed consistently
 /// across the entire file. Different instances will be named differently
 /// even if they have the same name, this makes it safe to use in code
 /// generation without needing global knowledge. See [JSNamer].
 ///
 // TODO(jmesserly): move into js_ast? add a boolean to Identifier?
 class TemporaryId extends Identifier {
+  static int __id = 0;

[Jennifer Messerly, 2015/05/12 16:23:46]

this helped for debugging, I could remove it though now that the bug is fixed?

+  final int _id = ++__id;
   TemporaryId(String name) : super(name);
+  toString() => super.toString() + ' $_id';
+}
+
+/// Creates a qualified identifier, without determining for sure if it needs to
+/// be qualified until [setQualified] is called.
+///
+/// This expression is transparent to visiting after [setQualified].
+class MaybeQualifiedId extends Expression {
+  Expression _expr;
+
+  final Identifier qualifier;
+  final Expression name;
+
+  MaybeQualifiedId(this.qualifier, this.name) {
+    _expr = new PropertyAccess(qualifier, name);
+  }
+
+  /// Helper to create an [Identifier] from something that starts as a property.
+  static identifier(LiteralString propertyName) =>
+      new Identifier(propertyName.valueWithoutQuotes);
+
+  void setQualified(bool qualified) {
+    if (!qualified && name is LiteralString) {
+      _expr = identifier(name);
+    }
+  }
+
+  int get precedenceLevel => _expr.precedenceLevel;
+
+  accept(NodeVisitor visitor) => _expr.accept(visitor);
+
+  void visitChildren(NodeVisitor visitor) => _expr.visitChildren(visitor);
 }
 
 /// This class has two purposes:
 ///
 /// * rename JS identifiers to avoid keywords.
 /// * rename temporary variables to avoid colliding with user-specified names,
 ///   or other temporaries
 ///
-/// Each instance of [JSTemporary] is treated as a unique variable, with its
+/// Each instance of [TemporaryId] is treated as a unique variable, with its
 /// `name` field simply the suggestion of what name to use. By contrast
 /// [Identifiers] are never renamed unless they are an invalid identifier, like
 /// `function` or `instanceof`, and their `name` field controls whether they
 /// refer to the same variable.
 class TemporaryNamer extends LocalNamer {
   final Map<Object, String> renames;
 
   TemporaryNamer(Node node) : renames = new _RenameVisitor.build(node).renames;
 
   String getName(Identifier node) {
@@ skipping 26 matching lines @@
 
   /// Nested functions, these are visited after everything else so the names
   /// they might need are in scope.
   final functions = new List<FunctionExpression>();
 
   _FunctionScope(this.parent);
 }
 
 /// Collects all names used in the visited tree.
 class _RenameVisitor extends VariableDeclarationVisitor {
-  final pendingRenames = new Map<Object, Set<_FunctionScope>>();
-  final renames = new HashMap<Object, String>();
+  final pendingRenames = new Map<Object, Set<_FunctionScope>>.identity();
+  final renames = new HashMap<Object, String>.identity();
 
   final _FunctionScope rootScope = new _FunctionScope(null);
   _FunctionScope scope;
 
   _RenameVisitor.build(Node root) {
     scope = rootScope;
     root.accept(this);
     _finishFunctions();
     _finishNames();
   }
@@ skipping 23 matching lines @@
     _markUsed(node, id, declScope);
   }
 
   _markUsed(Identifier node, Object id, _FunctionScope declScope) {
     // If it needs rename, we can't add it to the used name set yet, instead we
     // will record all scopes it is visible in.
     Set<_FunctionScope> usedIn = null;
     if (needsRename(node)) {
       usedIn = pendingRenames.putIfAbsent(id, () => new HashSet());
     }
-
     for (var s = scope, end = declScope.parent; s != end; s = s.parent) {
       if (usedIn != null) {
         usedIn.add(s);
       } else {
         s.used.add(node.name);
       }
     }
   }
 
   visitFunctionExpression(FunctionExpression node) {
@@ skipping 48 matching lines @@
         candidate = '${name}\$$i';
       }
     }
     return candidate;
   }
 }
 
 bool needsRename(Identifier node) =>
     node is TemporaryId || node.allowRename && invalidVariableName(node.name);
 
-Object /*String|JSTemporary*/ identifierKey(Identifier node) =>
+Object /*String|TemporaryId*/ identifierKey(Identifier node) =>
     node is TemporaryId ? node : node.name;
 
 /// Returns true for invalid JS variable names, such as keywords.
 /// Also handles invalid variable names in strict mode, like "arguments".
 bool invalidVariableName(String keyword, {bool strictMode: true}) {
   switch (keyword) {
     case "break":
     case "case":
     case "catch":
     case "class":
@@ skipping 40 matching lines @@
 /// In particular, "caller" "callee" and "arguments" cannot be used.
 bool invalidStaticFieldName(String name) {
   switch (name) {
     case "arguments":
     case "caller":
     case "callee":
       return true;
   }
   return false;
 }