Suppress generation of JsGlobal and JsType code and use window as the default value instead of {} f…

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;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 16 matching lines @@
 import 'package:dev_compiler/src/checker/rules.dart';
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 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$';
 
+bool _isAnnotationType(Annotation m, String name) => m.name.name == name;
+
+Annotation _getAnnotation(AnnotatedNode node, String name) => node.metadata
+    .firstWhere((annotation) => _isAnnotationType(annotation, name),
+        orElse: () => null);
+
+Annotation _getJsNameAnnotation(AnnotatedNode node) =>
+    _getAnnotation(node, "JsName");
+
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
   /// The variable for the current catch clause
   String _catchParameter;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashSet<String>();
   final _pendingPrivateNames = <String>[];
 
   JSCodegenVisitor(LibraryInfo libraryInfo, TypeRules rules)
       : libraryInfo = libraryInfo,
         rules = rules;
 
   Element get currentLibrary => libraryInfo.library;
 
   JS.Program generateLibrary(
       Iterable<CompilationUnit> units, CheckerReporter reporter) {
+    var unit = units.first;
+    var jsDefaultValue = '{}';
+    if (unit.directives.isNotEmpty) {
+      var annotation = _getJsNameAnnotation(unit.directives.first);
+      if (annotation != null) {
+        var arguments = annotation.arguments.arguments;
+        if (!arguments.isEmpty) {
+          var namedExpression = arguments.first as NamedExpression;
+          var literal = namedExpression.expression as SimpleStringLiteral;
+          jsDefaultValue = literal.stringValue;
+        }
+      }
+    }
     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(_visit(unit));
       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('$_EXPORTS.# = #;', [name, name]));
     }
 
     var name = jsLibraryName(libraryInfo.library);
+
+    var defaultValue = js.call(jsDefaultValue);
     return new JS.Program([
       js.statement('var #;', name),
-      js.statement("(function($_EXPORTS) { 'use strict'; #; })(# || (# = {}));",
-          [body, name, name])
+      js.statement("(function($_EXPORTS) { 'use strict'; #; })(# || (# = #));",
+          [body, name, name, defaultValue])
     ]);
   }
 
   JS.Statement _initPrivateSymbol(String name) =>
       js.statement('let # = Symbol(#);', [name, js.string(name, "'")]);
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
@@ skipping 127 matching lines @@
     var dynInst = js.statement('let # = #(#);', [name, genericName, typeArgs]);
 
     // TODO(jmesserly): is it worth exporting both names? Alternatively we could
     // put the generic type constructor on the <dynamic> instance.
     if (isPublic(name)) _exports.add('${name}\$');
     return new JS.Block([genericDef, dynInst]);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
+    if (_getJsNameAnnotation(node) != null) return null;
+
     currentClass = node;
 
     var body = <JS.Statement>[];
 
     var name = node.name.name;
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
@@ skipping 1795 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }