pkg/smoke: support latest analyzer version and formatted code

lib/codegen/recorder.dart

 // Copyright (c) 2014, 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.
 
 /// Records accesses to Dart program declarations and generates code that will
 /// allow to do the same accesses at runtime using `package:smoke/static.dart`.
 /// Internally, this library relies on the `analyzer` to extract data from the
 /// program, and then uses [SmokeCodeGenerator] to produce the code needed by
 /// the smoke system.
 ///
@@ skipping 58 matching lines @@
 
   /// Adds any declaration and superclass information that is needed to answer a
   /// query on [type] that matches [options]. Also adds symbols, getters, and
   /// setters if [includeAccessors] is true. If [results] is not null, it will
   /// be filled up with the members that match the query.
   void runQuery(ClassElement type, QueryOptions options,
       {bool includeAccessors: true, List results}) {
     if (type.type.isObject) return; // We don't include Object in query results.
     var id = _typeFor(type);
     var parent = type.supertype != null ? type.supertype.element : null;
-    if (options.includeInherited && parent != null &&
+    if (options.includeInherited &&
+        parent != null &&
         parent != options.includeUpTo) {
       lookupParent(type);
       runQuery(parent, options, includeAccessors: includeAccessors);
       var parentId = _typeFor(parent);
       for (var m in type.mixins) {
         var mixinClass = m.element;
         var mixinId = _mixins[parentId][mixinClass];
         _runQueryInternal(
             mixinClass, mixinId, options, includeAccessors, results);
         parentId = mixinId;
       }
     }
     _runQueryInternal(type, id, options, includeAccessors, results);
   }
 
   /// Helper for [runQuery]. This runs the query only on a specific [type],
   /// which could be a class or a mixin labeled by [id].
   // TODO(sigmund): currently we materialize mixins in smoke/static.dart,
   // we should consider to include the mixin declaration information directly,
   // and remove the duplication we have for mixins today.
   void _runQueryInternal(ClassElement type, TypeIdentifier id,
       QueryOptions options, bool includeAccessors, List results) {
-
     skipBecauseOfAnnotations(Element e) {
       if (options.withAnnotations == null) return false;
       return !_matchesAnnotation(e.metadata, options.withAnnotations);
     }
 
     if (options.includeFields) {
       for (var f in type.fields) {
         if (f.isStatic) continue;
         if (f.isSynthetic) continue; // exclude getters
         if (options.excludeFinal && f.isFinal) continue;
         var name = f.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(f)) continue;
         if (results != null) results.add(f);
         generator.addDeclaration(id, name, _typeFor(f.type.element),
-            isField: true, isFinal: f.isFinal,
+            isField: true,
+            isFinal: f.isFinal,
             annotations: _copyAnnotations(f));
         if (includeAccessors) _addAccessors(name, !f.isFinal);
       }
     }
 
     if (options.includeProperties) {
       for (var a in type.accessors) {
         if (a is! PropertyAccessorElement) continue;
         if (a.isStatic || !a.isGetter) continue;
         var v = a.variable;
         if (v is FieldElement && !v.isSynthetic) continue; // exclude fields
         if (options.excludeFinal && v.isFinal) continue;
         var name = v.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(a)) continue;
         if (results != null) results.add(a);
         generator.addDeclaration(id, name, _typeFor(a.type.returnType.element),
-            isProperty: true, isFinal: v.isFinal,
+            isProperty: true,
+            isFinal: v.isFinal,
             annotations: _copyAnnotations(a));
         if (includeAccessors) _addAccessors(name, !v.isFinal);
       }
     }
 
     if (options.includeMethods) {
       for (var m in type.methods) {
         if (m.isStatic) continue;
         var name = m.displayName;
         if (options.matches != null && !options.matches(name)) continue;
         if (skipBecauseOfAnnotations(m)) continue;
         if (results != null) results.add(m);
-        generator.addDeclaration(id, name,
-            new TypeIdentifier('dart:core', 'Function'), isMethod: true,
-            annotations: _copyAnnotations(m));
+        generator.addDeclaration(
+            id, name, new TypeIdentifier('dart:core', 'Function'),
+            isMethod: true, annotations: _copyAnnotations(m));
         if (includeAccessors) _addAccessors(name, false);
       }
     }
   }
 
   /// Adds the declaration of [name] if it was found in [type]. If [recursive]
   /// is true, then we continue looking up [name] in the parent classes until we
   /// find it or we reach [includeUpTo] or Object. Returns whether the
   /// declaration was found.  When a declaration is found, add also a symbol,
   /// getter, and setter if [includeAccessors] is true.
   bool lookupMember(ClassElement type, String name, {bool recursive: false,
-      bool includeAccessors: true, ClassElement includeUpTo}) =>
-    _lookupMemberInternal(type, _typeFor(type), name, recursive,
-        includeAccessors, includeUpTo);
+          bool includeAccessors: true, ClassElement includeUpTo}) =>
+      _lookupMemberInternal(
+          type, _typeFor(type), name, recursive, includeAccessors, includeUpTo);
 
   /// Helper for [lookupMember] that walks up the type hierarchy including mixin
   /// classes.
   bool _lookupMemberInternal(ClassElement type, TypeIdentifier id, String name,
       bool recursive, bool includeAccessors, ClassElement includeUpTo) {
     // Exclude members from [Object].
     if (type.type.isObject) return false;
     generator.addEmptyDeclaration(id);
     for (var f in type.fields) {
       if (f.displayName != name) continue;
       if (f.isSynthetic) continue; // exclude getters
-      generator.addDeclaration(id, name,
-          _typeFor(f.type.element), isField: true, isFinal: f.isFinal,
-          isStatic: f.isStatic, annotations: _copyAnnotations(f));
+      generator.addDeclaration(id, name, _typeFor(f.type.element),
+          isField: true,
+          isFinal: f.isFinal,
+          isStatic: f.isStatic,
+          annotations: _copyAnnotations(f));
       if (includeAccessors && !f.isStatic) _addAccessors(name, !f.isFinal);
       return true;
     }
 
     for (var a in type.accessors) {
       if (a is! PropertyAccessorElement) continue;
       // TODO(sigmund): support setters without getters.
       if (!a.isGetter) continue;
       if (a.displayName != name) continue;
       var v = a.variable;
       if (v is FieldElement && !v.isSynthetic) continue; // exclude fields
-      generator.addDeclaration(id, name,
-          _typeFor(a.type.returnType.element), isProperty: true,
-          isFinal: v.isFinal, isStatic: a.isStatic,
+      generator.addDeclaration(id, name, _typeFor(a.type.returnType.element),
+          isProperty: true,
+          isFinal: v.isFinal,
+          isStatic: a.isStatic,
           annotations: _copyAnnotations(a));
       if (includeAccessors && !v.isStatic) _addAccessors(name, !v.isFinal);
       return true;
     }
 
     for (var m in type.methods) {
       if (m.displayName != name) continue;
-      generator.addDeclaration(id, name,
-          new TypeIdentifier('dart:core', 'Function'), isMethod: true,
-          isStatic: m.isStatic, annotations: _copyAnnotations(m));
+      generator.addDeclaration(
+          id, name, new TypeIdentifier('dart:core', 'Function'),
+          isMethod: true,
+          isStatic: m.isStatic,
+          annotations: _copyAnnotations(m));
       if (includeAccessors) {
         if (m.isStatic) {
           generator.addStaticMethod(id, name);
           generator.addSymbol(name);
         } else {
           _addAccessors(name, false);
         }
       }
       return true;
     }
 
     if (recursive) {
       lookupParent(type);
       var parent = type.supertype != null ? type.supertype.element : null;
       if (parent == null || parent == includeUpTo) return false;
       var parentId = _typeFor(parent);
       for (var m in type.mixins) {
         var mixinClass = m.element;
         var mixinId = _mixins[parentId][mixinClass];
-        if (_lookupMemberInternal(mixinClass, mixinId, name, false,
-              includeAccessors, includeUpTo)) {
+        if (_lookupMemberInternal(
+            mixinClass, mixinId, name, false, includeAccessors, includeUpTo)) {
           return true;
         }
         parentId = mixinId;
       }
-      return _lookupMemberInternal(parent, parentId, name, true,
-          includeAccessors, includeUpTo);
+      return _lookupMemberInternal(
+          parent, parentId, name, true, includeAccessors, includeUpTo);
     }
     return false;
   }
 
   /// Add information so smoke can invoke the static method [type].[name].
   void addStaticMethod(ClassElement type, String name) {
     generator.addStaticMethod(_typeFor(type), name);
   }
 
   /// Adds [name] as a symbol, a getter, and optionally a setter in [generator].
@@ skipping 43 matching lines @@
 
     throw new UnsupportedError('unsupported annotation $annotation');
   }
 
   /// Converts [expression] into a [ConstExpression].
   ConstExpression _convertExpression(Expression expression) {
     if (expression is StringLiteral) {
       return new ConstExpression.string(expression.stringValue);
     }
 
-    if (expression is BooleanLiteral || expression is DoubleLiteral ||
-        expression is IntegerLiteral || expression is NullLiteral) {
+    if (expression is BooleanLiteral ||
+        expression is DoubleLiteral ||
+        expression is IntegerLiteral ||
+        expression is NullLiteral) {
       return new CodeAsConstExpression("${(expression as dynamic).value}");
     }
 
     if (expression is Identifier) {
       var element = expression.bestElement;
       if (element == null || !element.isPublic) {
         throw new UnsupportedError('private constants are not supported');
       }
 
       var url = importUrlFor(element.library);
@@ skipping 15 matching lines @@
     throw new UnimplementedError('expression convertion not implemented in '
         'smoke.codegen.recorder (${expression.runtimeType} $expression)');
   }
 }
 
 /// Returns whether [metadata] contains any annotation that is either equal to
 /// an annotation in [queryAnnotations] or whose type is a subclass of a type
 /// listed in [queryAnnotations]. This is equivalent to the check done in
 /// `src/common.dart#matchesAnnotation`, except that this is applied to
 /// static metadata as it was provided by the analyzer.
-bool _matchesAnnotation(Iterable<ElementAnnotation> metadata,
-    Iterable<Element> queryAnnotations) {
+bool _matchesAnnotation(
+    Iterable<ElementAnnotation> metadata, Iterable<Element> queryAnnotations) {
   for (var meta in metadata) {
     var element = meta.element;
     var exp;
     var type;
     if (element is PropertyAccessorElement) {
       exp = element.variable;
       type = exp.evaluationResult.value.type;
     } else if (element is ConstructorElement) {
       exp = element;
       type = element.enclosingElement.type;
@@ skipping 36 matching lines @@
 
   /// If [withAnnotation] is not null, then it should be a list of types, so
   /// only symbols that are annotated with instances of those types are
   /// included.
   final List<Element> withAnnotations;
 
   /// If [matches] is not null, then only those fields, properties, or methods
   /// that match will be included.
   final NameMatcher matches;
 
-  const QueryOptions({
-      this.includeFields: true,
-      this.includeProperties: true,
-      this.includeInherited: true,
-      this.includeUpTo: null,
-      this.excludeFinal: false,
-      this.includeMethods: false,
-      this.withAnnotations: null,
-      this.matches: null});
+  const QueryOptions({this.includeFields: true, this.includeProperties: true,
+      this.includeInherited: true, this.includeUpTo: null,
+      this.excludeFinal: false, this.includeMethods: false,
+      this.withAnnotations: null, this.matches: null});
 }
 
 /// Predicate that tells whether [name] should be included in query results.
 typedef bool NameMatcher(String name);