[js] simplify qualified names

lib/src/codegen/js_codegen.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_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'ast_builder.dart' show AstBuilder;
-import 'reify_coercions.dart' show CoercionReifier;
+import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
 // TODO(jmesserly): import from its own package
 import '../js/js_ast.dart' as JS;
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../compiler.dart' show AbstractCompiler;
 import '../checker/rules.dart';
 import '../info.dart';
 import '../options.dart' show CodegenOptions;
@@ skipping 45 matching lines @@
   JS.TemporaryId _asyncStarController;
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
   final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _moduleItems = <JS.Statement>[];
   final _temps = new HashMap<Element, JS.TemporaryId>();
-  final _qualifiedIds = new HashMap<Element, JS.MaybeQualifiedId>();
-  final _qualifiedGenericIds = new HashMap<Element, JS.MaybeQualifiedId>();
+  final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _dartxVar = new JS.Identifier('dartx');
   final _exportsVar = new JS.TemporaryId('exports');
   final _runtimeLibVar = new JS.Identifier('dart');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   ConstFieldVisitor _constField;
 
@@ skipping 65 matching lines @@
         }
       }
     }
 
     // Flush any unwritten fields/properties.
     _flushLazyFields(_moduleItems);
     _flushLibraryProperties(_moduleItems);
 
     // Mark all qualified names as qualified or not, depending on if they need
     // to be loaded lazily or not.
-    unqualifyIfNeeded(Element e, JS.MaybeQualifiedId id) {
-      id.setQualified(!_loader.isLoaded(e));
+    for (var elementIdPairs in _qualifiedIds) {
+      var element = elementIdPairs.e0;
+      var id = elementIdPairs.e1;
+      id.setQualified(!_loader.isLoaded(element));
     }
-    _qualifiedIds.forEach(unqualifyIfNeeded);
-    _qualifiedGenericIds.forEach(unqualifyIfNeeded);
 
     if (_exports.isNotEmpty) _moduleItems.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       _moduleItems.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
     var jsPath = compiler.getModuleName(currentLibrary.source.uri);
 
@@ skipping 1286 matching lines @@
     // type literal
     if (element is ClassElement ||
         element is DynamicElementImpl ||
         element is FunctionTypeAliasElement) {
       return _emitTypeName(
           fillDynamicTypeArgs((element as dynamic).type, types));
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
-      return _maybeQualifiedName(
-          element, _emitMemberName(name, isStatic: true));
+      return _maybeQualifiedName(element);
     }
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
       var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
       // For static methods, we add the raw type name, without generics or
@@ skipping 139 matching lines @@
       Iterable jsArgs = null;
       if (args.any((a) => a != types.dynamicType)) {
         jsArgs = args.map(_emitTypeName);
       } else if (lowerGeneric || isCurrentClass) {
         // When creating a `new S<dynamic>` we try and use the raw form
         // `new S()`, but this does not work if we're inside the same class,
         // because `S` refers to the current S<T> we are generating.
         jsArgs = [];
       }
       if (jsArgs != null) {
-        var genericName = _maybeQualifiedName(
-            element, _propertyName('$name\$'), _qualifiedGenericIds);
+        var genericName = _maybeQualifiedName(element, '$name\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
-    return _maybeQualifiedName(element, _propertyName(name));
+    return _maybeQualifiedName(element);
   }
 
-  JS.Expression _maybeQualifiedName(Element e, JS.Expression name,
-      [Map<Element, JS.MaybeQualifiedId> idTable]) {
+  JS.Expression _maybeQualifiedName(Element e, [String name]) {
     var libName = _libraryName(e.library);
-    if (idTable == null) idTable = _qualifiedIds;
+    var nameExpr = _propertyName(name ?? e.name);
 
-    // Mutable top-level fields should always be qualified.
+    // Always qualify:
+    // * mutable top-level fields
+    // * elements from other libraries
     bool mutableTopLevel = e is TopLevelVariableElement && !e.isConst;
-    if (e.library != currentLibrary || mutableTopLevel) {
-      return new JS.PropertyAccess(libName, name);
+    bool fromAnotherLibrary = e.library != currentLibrary;
+    if (mutableTopLevel || fromAnotherLibrary) {
+      return new JS.PropertyAccess(libName, nameExpr);
     }
 
-    return idTable.putIfAbsent(e, () => new JS.MaybeQualifiedId(libName, name));
+    var id = new JS.MaybeQualifiedId(libName, nameExpr);
+    _qualifiedIds.add(new Tuple2(e, id));
+    return id;
   }
 
   @override
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
     var op = node.operator.lexeme;
     assert(op.endsWith('='));
     op = op.substring(0, op.length - 1); // remove trailing '='
@@ skipping 1646 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }