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;
+
+bool _hasAnnotationType(AnnotatedNode node, String name) =>
+    node.metadata.any((annotation) => _isAnnotationType(annotation, name));
+
 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;
+  bool _containsJsGlobals = false;

[Jennifer Messerly, 2015/03/17 16:39:18]

should this be explicit on the library tag? e.g. library tag declares that it is
describing APIs on JS "window" object:

@JsGlobal("window")
library dom;

That way we aren't hardcoding "window", and we don't need to infer if the code
had a @JsGlobal inside. Like if we removed the "document" accessor, it would be
nice if the dom.js file still worked

[Jacob, 2015/03/17 21:22:44]

Discussed offline. Switched to @JsName here and for JsType and removed JsGlobal.

 
   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;
@@ skipping 15 matching lines @@
     }
 
     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 = _containsJsGlobals ? 'window' : '{}';

[Jennifer Messerly, 2015/03/17 16:39:18]

normally we'd do this as an interpolated expression:

var defaultValue = js.call(_containsJsGlobals ? 'window' : '{}');

js.call makes an expression. It'll cache the resulting AST. slightly faster than
interpolating this as a string below

[Jacob, 2015/03/17 21:22:44]

Done.

     return new JS.Program([
       js.statement('var #;', name),
-      js.statement("(function($_EXPORTS) { 'use strict'; #; })(# || (# = {}));",
+      js.statement(
+          "(function($_EXPORTS) { 'use strict'; #; })(# || (# = $defaultValue));",

[Jennifer Messerly, 2015/03/17 16:39:18]

this should be:
"(function($_EXPORTS) { 'use strict'; #; })(# || (# = #));"

[Jacob, 2015/03/17 21:22:44]

Done.

           [body, name, name])

[Jennifer Messerly, 2015/03/17 16:39:18]

[body, name, name, defaultValue]

[Jacob, 2015/03/17 21:22:44]

Done.

     ]);
   }
 
   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 (_hasAnnotationType(node, 'JsType')) 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 663 matching lines @@
   JS.Statement visitAssertStatement(AssertStatement node) =>
       // TODO(jmesserly): only emit in checked mode.
       js.statement('dart.assert(#);', _visit(node.condition));
 
   @override
   JS.Return visitReturnStatement(ReturnStatement node) =>
       new JS.Return(_visit(node.expression));
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+    if (_hasAnnotationType(node, 'JsGlobal')) {
+      _containsJsGlobals = true;

[Jennifer Messerly, 2015/03/17 16:39:18]

per suggestion above, this won't be needed

+      return null;
+    }
     var body = <JS.Statement>[];
 
     for (var field in node.variables.variables) {
       if (field.isConst) {
         // constant fields don't change, so we can generate them as `let`
         // but add them to the module's exports
         var name = field.name.name;
         body.add(js.statement('let # = #;', [
           new JS.VariableDeclaration(name),
           _visitInitializer(field)
@@ skipping 26 matching lines @@
       //    var result = [];
       //    result.length = length;
       var savedCascadeTemp = _cascadeTarget;
       _cascadeTarget = last.name;
 
       variables = _visitList(node.variables.take(node.variables.length - 1));
       variables.add(new JS.VariableInitialization(
           new JS.VariableDeclaration(last.name.name),
           _visit(lastInitializer.target)));
 
-      var result =
-          <JS.Expression>[new JS.VariableDeclarationList('let', variables)];
+      var result = <JS.Expression>[

[Siggi Cherem (dart-lang), 2015/03/17 01:25:36]

DBC - you might need to run pub-ugprade, seems like an old version of the
formatter.

I just noticed this earlier today so I'm sending a CL to pin the formatter to a
precise version to avoid running into this in the future (see
https://codereview.chromium.org/1011003002/)

+        new JS.VariableDeclarationList('let', variables)
+      ];
       result.addAll(_visitList(lastInitializer.cascadeSections));
       _cascadeTarget = savedCascadeTemp;
       return _statement(result.map((e) => new JS.ExpressionStatement(e)));
     } else {
       variables = _visitList(node.variables);
     }
 
     return new JS.VariableDeclarationList('let', variables);
   }
 
@@ skipping 34 matching lines @@
             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($_EXPORTS, { # });',
-        [_properties.map(_emitTopLevelProperty)]));
+    body.add(js.statement('dart.copyProperties($_EXPORTS, { # });', [
+      _properties.map(_emitTopLevelProperty)
+    ]));
     _properties.clear();
   }
 
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
       _expressionStatement(_visit(node.variables));
 
   @override
   visitConstructorName(ConstructorName node) {
@@ skipping 571 matching lines @@
 
   @override
   visitDoubleLiteral(DoubleLiteral node) => js.number(node.value);
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitListLiteral(ListLiteral node) {
     // TODO(jmesserly): make this faster. We're wasting an array.
-    var list = js.call('new List.from(#)',
-        [new JS.ArrayInitializer(_visitList(node.elements))]);
+    var list = js.call('new List.from(#)', [
+      new JS.ArrayInitializer(_visitList(node.elements))
+    ]);
     if (node.constKeyword != null) {
       list = js.commentExpression('Unimplemented const', list);
     }
     return list;
   }
 
   @override
   visitMapLiteral(MapLiteral node) {
     var entries = node.entries;
     var mapArguments = null;
@@ skipping 305 matching lines @@
       CheckerReporter reporter) {
     JS.Program jsTree =
         new JSCodegenVisitor(info, rules).generateLibrary(units, reporter);
 
     var outputPath = path.join(outDir, jsOutputPath(info, root));
     new Directory(path.dirname(outputPath)).createSync(recursive: true);
 
     if (options.emitSourceMaps) {
       var outFilename = path.basename(outputPath);
       var printer = new srcmaps.Printer(outFilename);
-      _writeNode(
-          new SourceMapPrintingContext(printer, path.dirname(outputPath)),
-          jsTree);
+      _writeNode(new SourceMapPrintingContext(
+          printer, path.dirname(outputPath)), jsTree);
       printer.add('//# sourceMappingURL=$outFilename.map');
       // Write output file and source map
       var text = printer.text;
       new File(outputPath).writeAsStringSync(text);
       new File('$outputPath.map').writeAsStringSync(printer.map);
       return computeHash(text);
     } else {
       var text = jsNodeToString(jsTree);
       new File(outputPath).writeAsStringSync(text);
       return computeHash(text);
@@ skipping 87 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;
   }
 }