fixes #69, avoid module name inside module scope

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 ddc.src.codegen.js_codegen;
 
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 12 matching lines @@
 import 'package:dev_compiler/src/report.dart';
 import 'package:dev_compiler/src/utils.dart';
 import 'code_generator.dart';
 
 // This must match the optional parameter name used in runtime.js
 const String _jsNamedParameterName = r'opt$';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
-  final String _libraryName;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
 
   JSCodegenVisitor(LibraryInfo libraryInfo, TypeRules rules)
       : libraryInfo = libraryInfo,
-        rules = rules,
-        _libraryName = jsLibraryName(libraryInfo.library);
+        rules = rules;
 
   Element get currentLibrary => libraryInfo.library;
 
   JS.Block generateLibrary(
       Iterable<CompilationUnit> units, CheckerReporter reporter) {
     var body = <JS.Statement>[];
     for (var unit in units) {
       // TODO(jmesserly): this is needed because RestrictedTypeRules can send
       // messages to CheckerReporter, for things like missing types.
       // We should probably refactor so this can't happen.
       var source = unit.element.source;
       _constEvaluator = new ConstantEvaluator(source, rules.provider);
       reporter.enterSource(source);
       body.add(unit.accept(this));
       reporter.leaveSource();
     }
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
-      body.add(js.statement('#.# = #;', [_libraryName, name, name]));
+      body.add(js.statement('$_EXPORTS.# = #;', [name, name]));
     }
 
-    var name = _libraryName;
+    var name = jsLibraryName(libraryInfo.library);
     return new JS.Block([
       js.statement('var #;', name),
       js.statement('''
-        (function (#) {
+        (function ($_EXPORTS) {
           'use strict';
           #;
         })(# || (# = {}));
-      ''', [name, body, name, name])
+      ''', [body, name, name])
     ]);
   }
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
@@ skipping 539 matching lines @@
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.VariableUse(node.name));
     }
     var name = node.name;
     if (e.enclosingElement is CompilationUnitElement &&
         (e.library != libraryInfo.library || _needsModuleGetter(e))) {
-      return js.call('#.#', [jsLibraryName(e.library), name]);
+      return js.call('#.#', [_libraryName(e.library), name]);
     } else if (currentClass != null && _needsImplicitThis(e)) {
       return js.call('this.#', name);
     }
     return new JS.VariableUse(name);
   }
 
   JS.Expression _emitTypeName(DartType type) {
     var name = type.name;
     var lib = type.element.library;
     if (name == '') {
       // TODO(jmesserly): remove when we're using coercion reifier.
       return _unimplementedCall('Unimplemented type $type');
     }
 
     var typeArgs = null;
     if (type is ParameterizedType) {
       // TODO(jmesserly): this is a workaround for an analyzer bug, see:
       // https://github.com/dart-lang/dart-dev-compiler/commit/a212d59ad046085a626dd8d16881cdb8e8b9c3fa
       if (type is! FunctionType || type.element is FunctionTypeAlias) {
         var args = type.typeArguments;
         if (args.any((a) => a != rules.provider.dynamicType)) {
           name = '$name\$';
           typeArgs = args.map(_emitTypeName);
         }
       }
     }
 
     JS.Expression result;
     if (lib != currentLibrary && lib != null) {
-      result = js.call('#.#', [jsLibraryName(lib), name]);
+      result = js.call('#.#', [_libraryName(lib), name]);
     } else {
       result = new JS.VariableUse(name);
     }
 
     if (typeArgs != null) {
       result = js.call('#(#)', [result, typeArgs]);
     }
     return result;
   }
 
@@ skipping 269 matching lines @@
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
     var value = _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value != null ? value : new JS.LiteralNull();
   }
 
   void _flushLazyFields(List<JS.Statement> body) {
-    var code = _emitLazyFields(_libraryName, _lazyFields);
+    var code = _emitLazyFields(_EXPORTS, _lazyFields);
     if (code != null) body.add(code);
     _lazyFields.clear();
   }
 
   JS.Statement _emitLazyFields(
       String objExpr, List<VariableDeclaration> fields) {
     if (fields.isEmpty) return null;
 
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       methods.add(new JS.Method(new JS.PropertyName(name),
           js.call('function() { return #; }', node.initializer.accept(this)),
           isGetter: true));
 
       // TODO(jmesserly): use a dummy setter to indicate writable.
       if (!node.isFinal) {
         methods.add(new JS.Method(
             new JS.PropertyName(name), js.call('function() {}'),
             isSetter: true));
       }
     }
 
     return js.statement(
         'dart.defineLazyProperties(#, { # })', [objExpr, methods]);
   }
 
   void _flushLibraryProperties(List<JS.Statement> body) {
     if (_properties.isEmpty) return;
-    body.add(js.statement('dart.copyProperties(#, { # });', [
-      _libraryName,
+    body.add(js.statement('dart.copyProperties($_EXPORTS, { # });', [
       _properties.map(_emitTopLevelProperty)
     ]));
     _properties.clear();
   }
 
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
       _expressionStatement(node.variables.accept(this));
 
@@ skipping 620 matching lines @@
     if (name == '[]=') return 'set';
     return name;
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
+  /// Choose a canonical name from the library element.
+  /// This never uses the library's name (the identifier in the `library`
+  /// declaration) as it doesn't have any meaningful rules enforced.
+  String _libraryName(LibraryElement library) {
+    if (library == libraryInfo.library) return _EXPORTS;
+    return jsLibraryName(library);
+  }
+
   String _maybeBindThis(node) {
     if (currentClass == null) return '';
     var visitor = _BindThisVisitor._instance;
     visitor._bindThis = false;
     node.accept(visitor);
     return visitor._bindThis ? '.bind(this)' : '';
   }
 
+  /// The name for the library's exports inside itself.
+  /// This much be a constant because we interpolate it into template strings,
+  /// and otherwise it would break caching for them.
+  /// `exports` was chosen as the most similar to ES module patterns.
+  static const String _EXPORTS = 'exports';
+
   static bool _needsImplicitThis(Element e) =>
       e is PropertyAccessorElement && !e.variable.isStatic ||
           e is ClassMemberElement && !e.isStatic && e is! ConstructorElement;
 }
 
 /// Returns true if the local variable is potentially mutated within [context].
 /// This accounts for closures that may have been created outside of [context].
 bool _isPotentiallyMutated(VariableElementImpl e, [AstNode context]) {
   if (e.isPotentiallyMutatedInClosure) {
     // TODO(jmesserly): this returns true incorrectly in some cases, because
@@ skipping 84 matching lines @@
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Path to file that will be generated for [info].
 // TODO(jmesserly): library directory should be relative to its package
 // root. For example, "package:dev_compiler/src/codegen/js_codegen.dart" would be:
 // "ddc/src/codegen/js_codegen.js" under the output directory.
 String jsOutputPath(LibraryInfo info) => '${info.name}/${info.name}.js';