use Analyzer's computed constants instead of pattern matching the annotation AST

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;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 15 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/utils.dart';
 
 import 'code_generator.dart';
 import 'js_names.dart';
 import 'js_metalet.dart';
 
-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");
-
-// TODO(jacobr): we would like to do something like the following
-// but we don't have summary support yet.
-// bool _supportJsExtensionMethod(AnnotatedNode node) =>
-//    _getAnnotation(node, "SupportJsExtensionMethod") != null;
-
 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
   SimpleIdentifier _catchParameter;
 
   ClassDeclaration currentClass;
@@ skipping 55 matching lines @@
   LibraryElement get currentLibrary => libraryInfo.library;
 
   /// 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.
   final JSTemporary _exportsVar = new JSTemporary('exports');
   final JSTemporary _namedArgTemp = new JSTemporary('opts');
 
   JS.Program emitLibrary(LibraryUnit library) {
-    var jsDefaultValue = '{}';
+    String jsDefaultValue = null;
     var unit = library.library;
     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 libraryDir = unit.directives.first;
+      if (libraryDir is LibraryDirective) {
+        var jsName = getAnnotationValue(libraryDir, _isJsNameAnnotation);
+        jsDefaultValue = getStringConstantField(jsName, 'name');
       }
     }
+    if (jsDefaultValue == null) jsDefaultValue = '{}';
+
     var body = <JS.Statement>[];
 
     // Collect classes we need to emit, used for:
     // * tracks what we've emitted so we don't emit twice
     // * provides a mapping from ClassElement back to the ClassDeclaration.
     for (var unit in library.partsThenLibrary) {
       for (var decl in unit.declarations) {
         if (decl is ClassDeclaration ||
             decl is ClassTypeAlias ||
             decl is FunctionTypeAlias) {
@@ skipping 178 matching lines @@
 
     var name = node.name.name;
     var heritage =
         js.call('dart.mixin(#)', [_visitList(node.withClause.mixinTypes)]);
     var classDecl = new JS.ClassDeclaration(
         new JS.ClassExpression(new JS.Identifier(name), heritage, []));
 
     return _finishClassDef(type, classDecl);
   }
 
-  JS.Statement _emitJsType(ClassDeclaration node, Annotation jsName) {
-    var dartName = node.name.name;
-    var jsTypeName = _getLiteralStringNamedArg(jsName, 'name');
+  JS.Statement _emitJsType(String dartClassName, DartObjectImpl jsName) {
+    var jsTypeName = getStringConstantField(jsName, 'name');
 
-    if (jsTypeName != null && jsTypeName != dartName) {
+    if (jsTypeName != null && jsTypeName != dartClassName) {
       // We export the JS type as if it was a Dart type. For example this allows
       // `dom.InputElement` to actually be HTMLInputElement.
       // TODO(jmesserly): if we had the JsName on the Element, we could just
       // generate it correctly when we refer to it.
-      if (isPublic(dartName)) _addExport(dartName);
-      return js.statement('let # = #;', [dartName, jsTypeName]);
+      if (isPublic(dartClassName)) _addExport(dartClassName);
+      return js.statement('let # = #;', [dartClassName, jsTypeName]);
     }
     return null;
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     // If we've already emitted this class, skip it.
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
-    var jsName = _getJsNameAnnotation(node);
-    if (jsName != null) return _emitJsType(node, jsName);
+    var jsName = getAnnotationValue(node, _isJsNameAnnotation);
+    if (jsName != null) return _emitJsType(node.name.name, jsName);
 
     currentClass = node;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
@@ skipping 2218 matching lines @@
         identical(parent.methodName, node)) return;
     if (parent is ConstructorName) return;
     if (parent is Label) return;
 
     if (node.inSetterContext() && node.staticElement == _variable) {
       _potentiallyMutated = true;
     }
   }
 }
 
-String _getLiteralStringNamedArg(Annotation annotation, String argName) {
-  if (annotation.arguments != null) {
-    var args = annotation.arguments.arguments;
-    if (args.isNotEmpty && args[0] is NamedExpression) {
-      NamedExpression named = args[0];
-      if (named.name.label.name == argName &&
-          named.expression is StringLiteral) {
-        return (named.expression as StringLiteral).stringValue;
-      }
-    }
-  }
-  return null;
+bool _isJsNameAnnotation(DartObjectImpl value) {
+  var type = value.type;
+  var library = type.element.library;
+  // TODO(jmesserly): move JsName to dart:js

[Jacob, 2015/04/14 20:54:33]

until we move it to dart:js can't we just be permissive and allow it any
library?
e.g. only check for
type.name == 'JsName'
Otherwise it is a  

[Jennifer Messerly, 2015/04/15 00:21:26]

hmmm. The current situation does indeed seem odd. Filed
https://github.com/dart-lang/dev_compiler/issues/135, for now I can remove the
check, though I suspect we'll end up with two libraries in the end (public one,
and _internal for our SDK libs to use)

+  return type.name == 'JsName' && (library.isDartCore || library.name == 'dom');
 }
+
+// TODO(jacobr): we would like to do something like the following
+// but we don't have summary support yet.
+// bool _supportJsExtensionMethod(AnnotatedNode node) =>
+//    _getAnnotation(node, "SupportJsExtensionMethod") != null;