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 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/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;
-
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // dart_runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
@@ skipping 38 matching lines @@
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
   JSCodegenVisitor(this.libraryInfo, this.rules, this._extensionMethods);
 
   LibraryElement get currentLibrary => libraryInfo.library;
   TypeProvider get types => rules.provider;
 
   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 = getConstantField(jsName, 'name', types.stringType);
       }
     }
+    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 = getConstantField(jsName, 'name', types.stringType);
 
-    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 2125 matching lines @@
 /// This method is conservative: it should never return `true` unless it is
 /// certain the [node] is stateless, because generated code may rely on the
 /// correctness of a `true` value. However it may return `false` for things
 /// that are in fact, stateless.
 bool _isStateless(Expression node, [AstNode context]) {
   if (node is SimpleIdentifier) {
     var e = node.staticElement;
     if (e is PropertyAccessorElement) e = e.variable;
     if (e is VariableElement && !e.isSynthetic) {
       if (e.isFinal) return true;
-
-      // TODO(jmesserly): remove this when isPotentiallyMutated* is available
-      // without the implementation class. Technically we shouldn't hit the
-      // ParameterMember case based on current usage of _isStateless, but this
-      // makes it clear we shouldn't rely on *Impl class.
-      if (e is Member) e = e.baseElement;
-
-      if (e is LocalVariableElementImpl || e is ParameterElementImpl) {
+      if (e is LocalVariableElement || e is ParameterElement) {
         // make sure the local isn't mutated in the context.
         return !_isPotentiallyMutated(e, context);
       }
     }
   }
   return false;
 }
 
 /// 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
-    // VariableResolverVisitor only checks that enclosingElement is not the
-    // function element, but enclosingElement can be something else in some
-    // cases (the block scope?). So it's more conservative than it could be.
-    return true;
-  }
+bool _isPotentiallyMutated(VariableElement e, [AstNode context]) {
+  if (e.isPotentiallyMutatedInClosure) return true;
   if (e.isPotentiallyMutatedInScope) {
     // Need to visit the context looking for assignment to this local.
     if (context != null) {
       var visitor = new _AssignmentFinder(e);
       context.accept(visitor);
       return visitor._potentiallyMutated;
     }
     return true;
   }
   return false;
 }
 
 /// Adapted from VariableResolverVisitor. Finds an assignment to a given
 /// local variable.
 // TODO(jmesserly): change type annotation to not be *Impl once
 // isPotentiallyMutated is available on VariableElement.
 class _AssignmentFinder extends RecursiveAstVisitor {
-  final VariableElementImpl _variable;
+  final VariableElement _variable;
   bool _potentiallyMutated = false;
 
   _AssignmentFinder(this._variable);
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     // Ignore if qualified.
     AstNode parent = node.parent;
     if (parent is PrefixedIdentifier &&
         identical(parent.identifier, node)) return;
     if (parent is PropertyAccess &&
         identical(parent.propertyName, node)) return;
     if (parent is MethodInvocation &&
         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;
-}
+// TODO(jmesserly): validate the library. See issue #135.

[Jacob, 2015/04/15 00:34:41]

Is this the style we're following for referencing issue #s?

[Jennifer Messerly, 2015/04/15 00:38:39]

No idea. I used to paste full links, but other github projects I've seen
sometimes use just numbers. In GitHub Flavored Markdown they auto-link, but the
code renderer doesn't do this (and in any case, most other tools wouldn't).

+bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == '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;