implement @JS classes

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 580 matching lines @@
     // `dom.InputElement` to actually be HTMLInputElement.
     // TODO(jmesserly): if we had the JS name on the Element, we could just
     // generate it correctly when we refer to it.
     return js.statement('# = #;', [_emitTopLevelName(e), jsTypeName]);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     var classElem = node.element;
 
+    // If this class is annotated with `@JS`, then there is nothing to emit.
+    if (findAnnotation(classElem, isPublicJSAnnotation) != null) return null;
+
     // If this is a JavaScript type, emit it now and then exit.
     var jsTypeDef = _emitJsType(classElem);
     if (jsTypeDef != null) return jsTypeDef;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
@@ skipping 2402 matching lines @@
     if (parent is ClassElement) {
       return getter
           ? parent.getGetter(element.name)
           : parent.getSetter(element.name);
     }
     return null;
   }
 
   JS.Expression _emitConstructorName(
       ConstructorElement element, DartType type, SimpleIdentifier name) {
+    var classElem = element.enclosingElement;
+    if (findAnnotation(classElem, isPublicJSAnnotation) != null) {
+      var annotationName = getAnnotationName(classElem, isPublicJSAnnotation);
+      var typeName = js.string(annotationName ?? classElem.name);
+      return new JS.PropertyAccess(new JS.Identifier('self'), typeName);
+    }
     var typeName = _emitType(type);
     if (name != null || element.isFactory) {
       var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
   @override
   visitConstructorName(ConstructorName node) {
@@ skipping 17 matching lines @@
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
       }
       var args = _visit(argumentList) as List<JS.Expression>;
       return isFactory ? new JS.Call(ctor, args) : new JS.New(ctor, args);
     }
+    if (_isObjectLiteral(element.enclosingElement)) {
+      return _emitObjectLiteral(argumentList);
+    }
     if (isConst) return _emitConst(emitNew);
     return emitNew();
   }
 
+  bool _isObjectLiteral(ClassElement classElem) {
+    return findAnnotation(classElem, isPublicJSAnnotation) != null &&
+        findAnnotation(classElem, isJSAnonymousAnnotation) != null;
+  }
+
+  JS.Expression _emitObjectLiteral(ArgumentList argumentList) {
+    var args = _visit(argumentList) as List<JS.Expression>;
+    if (args.isEmpty) {
+      return js.call('{}');
+    }
+    assert(args.single is JS.ObjectInitializer);
+    return args.single;
+  }
+
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     var element = node.staticElement;
     var constructor = node.constructorName;
     var name = constructor.name;
     var type = constructor.type.type;
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
@@ skipping 1364 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';