pkg/smoke: support latest analyzer version and formatted code

lib/codegen/generator.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.
 
 /// Library to generate code that can initialize the `StaticConfiguration` in
 /// `package:smoke/static.dart`.
 ///
 /// This library doesn't have any specific logic to extract information from
 /// Dart source code. To extract code using the analyzer, take a look at the
 /// `smoke.codegen.recorder` library.
@@ skipping 35 matching lines @@
   /// Static methods used on each type.
   final Map<TypeIdentifier, Set<String>> _staticMethods = new SplayTreeMap();
 
   /// Names that are used both as strings and symbols.
   final Set<String> _names = new SplayTreeSet();
 
   /// Prefixes associated with imported libraries.
   final Map<String, String> _libraryPrefix = {};
 
   /// Register that [name] is used as a getter in the code.
-  void addGetter(String name) { _getters.add(name); }
+  void addGetter(String name) {
+    _getters.add(name);
+  }
 
   /// Register that [name] is used as a setter in the code.
-  void addSetter(String name) { _setters.add(name); }
+  void addSetter(String name) {
+    _setters.add(name);
+  }
 
   /// Register that [name] might be needed as a symbol.
-  void addSymbol(String name) { _names.add(name); }
+  void addSymbol(String name) {
+    _names.add(name);
+  }
 
   /// Register that `cls.name` is used as a static method in the code.
   void addStaticMethod(TypeIdentifier cls, String name) {
-    var methods = _staticMethods.putIfAbsent(cls,
-        () => new SplayTreeSet<String>());
+    var methods =
+        _staticMethods.putIfAbsent(cls, () => new SplayTreeSet<String>());
     _addLibrary(cls.importUrl);
     methods.add(name);
   }
 
   int _mixins = 0;
 
   /// Creates a new type to represent a mixin. Use [comment] to help users
   /// figure out what mixin is being represented.
   TypeIdentifier createMixinType([String comment = '']) =>
       new TypeIdentifier(null, '_M${_mixins++}', comment);
@@ skipping 17 matching lines @@
   void addDeclaration(TypeIdentifier cls, String name, TypeIdentifier type,
       {bool isField: false, bool isProperty: false, bool isMethod: false,
       bool isFinal: false, bool isStatic: false,
       List<ConstExpression> annotations: const []}) {
     final count = (isField ? 1 : 0) + (isProperty ? 1 : 0) + (isMethod ? 1 : 0);
     if (count != 1) {
       throw new ArgumentError('Declaration must be one (and only one) of the '
           'following: a field, a property, or a method.');
     }
     var kind = isField ? 'FIELD' : isProperty ? 'PROPERTY' : 'METHOD';
-    _declarations.putIfAbsent(cls,
-        () => new SplayTreeMap<String, _DeclarationCode>());
+    _declarations.putIfAbsent(
+        cls, () => new SplayTreeMap<String, _DeclarationCode>());
     _addLibrary(cls.importUrl);
     var map = _declarations[cls];
 
     for (var exp in annotations) {
       for (var lib in exp.librariesUsed) {
         _addLibrary(lib);
       }
     }
 
     _addLibrary(type.importUrl);
-    var decl = new _DeclarationCode(name, type, kind, isFinal, isStatic,
-        annotations);
+    var decl =
+        new _DeclarationCode(name, type, kind, isFinal, isStatic, annotations);
     if (map.containsKey(name) && map[name] != decl) {
       throw new StateError('$type.$name already has a different declaration'
           ' (${map[name]} instead of $decl).');
     }
     map[name] = decl;
   }
 
   /// Register that we might try to read declarations of [type], even if no
   /// declaration exists. This informs the smoke system that querying for a
   /// member in this class might be intentional and not an error.
   void addEmptyDeclaration(TypeIdentifier type) {
     _addLibrary(type.importUrl);
-    _declarations.putIfAbsent(type,
-        () => new SplayTreeMap<String, _DeclarationCode>());
+    _declarations.putIfAbsent(
+        type, () => new SplayTreeMap<String, _DeclarationCode>());
   }
 
   /// Writes to [buffer] a line for each import that is needed by the generated
   /// code. The code added by [writeStaticConfiguration] depends on these
   /// imports.
   void writeImports(StringBuffer buffer) {
     DEFAULT_IMPORTS.forEach((i) => buffer.writeln(i));
     _libraryPrefix.forEach((url, prefix) {
       buffer.writeln("import '$url' as $prefix;");
     });
   }
 
   /// Writes to [buffer] top-level declarations that are used by the code
   /// generated in [writeStaticConfiguration]. These are typically declarations
   /// of empty classes that are then used as placeholders for mixin
   /// superclasses.
   void writeTopLevelDeclarations(StringBuffer buffer) {
     var types = new Set()
-        ..addAll(_parents.keys)
-        ..addAll(_parents.values)
-        ..addAll(_declarations.keys)
-        ..addAll(_declarations.values.expand(
-              (m) => m.values.map((d) => d.type)))
-        ..removeWhere((t) => t.importUrl != null);
+      ..addAll(_parents.keys)
+      ..addAll(_parents.values)
+      ..addAll(_declarations.keys)
+      ..addAll(_declarations.values.expand((m) => m.values.map((d) => d.type)))
+      ..removeWhere((t) => t.importUrl != null);
     for (var type in types) {
       buffer.write('abstract class ${type.name} {}');
       if (type.comment != null) buffer.write(' // ${type.comment}');
       buffer.writeln();
     }
   }
 
   /// Appends to [buffer] code that will create smoke's static configuration.
   /// For example, the code might be of the form:
   ///
@@ skipping 16 matching lines @@
   /// declarations from [writeTopLevelDeclarations] are included in the same
   /// library where this code will live.
   void writeStaticConfiguration(StringBuffer buffer, [int indent = 2]) {
     final spaces = ' ' * (indent + 4);
     var args = {};
 
     if (_getters.isNotEmpty) {
       args['getters'] = _getters.map((n) => '${_symbol(n)}: (o) => o.$n');
     }
     if (_setters.isNotEmpty) {
-      args['setters'] = _setters.map(
-          (n) => '${_symbol(n)}: (o, v) { o.$n = v; }');
+      args['setters'] =
+          _setters.map((n) => '${_symbol(n)}: (o, v) { o.$n = v; }');
     }
 
     if (_parents.isNotEmpty) {
       var parentsMap = [];
       _parents.forEach((child, parent) {
         var parent = _parents[child];
         parentsMap.add('${child.asCode(_libraryPrefix)}: '
-          '${parent.asCode(_libraryPrefix)}');
+            '${parent.asCode(_libraryPrefix)}');
       });
       args['parents'] = parentsMap;
     }
 
     if (_declarations.isNotEmpty) {
       var declarations = [];
       _declarations.forEach((type, members) {
         final sb = new StringBuffer()
-            ..write(type.asCode(_libraryPrefix))
-            ..write(': ');
+          ..write(type.asCode(_libraryPrefix))
+          ..write(': ');
         if (members.isEmpty) {
           sb.write('{}');
         } else {
           sb.write('{\n');
           members.forEach((name, decl) {
             var decl = members[name].asCode(_libraryPrefix);
             sb.write('${spaces}    ${_symbol(name)}: $decl,\n');
           });
           sb.write('${spaces}  }');
         }
         declarations.add(sb.toString());
       });
       args['declarations'] = declarations;
     }
 
     if (_staticMethods.isNotEmpty) {
       var methods = [];
       _staticMethods.forEach((type, members) {
         var className = type.asCode(_libraryPrefix);
         final sb = new StringBuffer()
-            ..write(className)
-            ..write(': ');
+          ..write(className)
+          ..write(': ');
         if (members.isEmpty) {
           sb.write('{}');
         } else {
           sb.write('{\n');
           for (var name in members) {
             sb.write('${spaces}    ${_symbol(name)}: $className.$name,\n');
           }
           sb.write('${spaces}  }');
         }
         methods.add(sb.toString());
       });
       args['staticMethods'] = methods;
     }
 
     if (_names.isNotEmpty) {
       args['names'] = _names.map((n) => "${_symbol(n)}: r'$n'");
     }
 
-    buffer..writeln('new StaticConfiguration(')
-        ..write('${spaces}checkedMode: false');
+    buffer
+      ..writeln('new StaticConfiguration(')
+      ..write('${spaces}checkedMode: false');
 
     args.forEach((name, mapContents) {
       buffer.writeln(',');
       // TODO(sigmund): use const map when Type can be keys (dartbug.com/17123)
       buffer.writeln('${spaces}$name: {');
       for (var entry in mapContents) {
         buffer.writeln('${spaces}  $entry,');
       }
       buffer.write('${spaces}}');
     });
@@ skipping 13 matching lines @@
   final TypeIdentifier type;
   final String kind;
   final bool isFinal;
   final bool isStatic;
   final List<ConstExpression> annotations;
 
   _DeclarationCode(this.name, this.type, this.kind, this.isFinal, this.isStatic,
       this.annotations);
 
   List<String> get librariesUsed => []
-      ..addAll(type.librariesUsed)
-      ..addAll(annotations.expand((a) => a.librariesUsed));
+    ..addAll(type.librariesUsed)
+    ..addAll(annotations.expand((a) => a.librariesUsed));
 
   String asCode(Map<String, String> libraryPrefixes) {
     var sb = new StringBuffer();
     sb.write('const Declaration(${_symbol(name)}, '
         '${type.asCode(libraryPrefixes)}');
     if (kind != 'FIELD') sb.write(', kind: $kind');
     if (isFinal) sb.write(', isFinal: true');
     if (isStatic) sb.write(', isStatic: true');
     if (annotations != null && annotations.isNotEmpty) {
       sb.write(', annotations: const [');
       bool first = true;
       for (var e in annotations) {
         if (!first) sb.write(', ');
         first = false;
         sb.write(e.asCode(libraryPrefixes));
       }
       sb.write(']');
     }
     sb.write(')');
     return sb.toString();
   }
 
   String toString() =>
       '(decl: $type.$name - $kind, $isFinal, $isStatic, $annotations)';
-  operator== (other) => other is _DeclarationCode && name == other.name && 
-      type == other.type && kind == other.kind && isFinal == other.isFinal &&
+  operator ==(other) => other is _DeclarationCode &&
+      name == other.name &&
+      type == other.type &&
+      kind == other.kind &&
+      isFinal == other.isFinal &&
       isStatic == other.isStatic &&
       compareLists(annotations, other.annotations);
   int get hashCode => name.hashCode + (31 * type.hashCode);
 }
 
 /// A constant expression that can be used as an annotation.
 abstract class ConstExpression {
 
   /// Returns the library URLs that needs to be imported for this
   /// [ConstExpression] to be a valid annotation.
@@ skipping 12 matching lines @@
     var value = string.replaceAll(r'\', r'\\').replaceAll(r"'", r"\'");
     return new CodeAsConstExpression("'$value'");
   }
 
   /// Create an expression of the form `prefix.variable_name`.
   factory ConstExpression.identifier(String importUrl, String name) =>
       new TopLevelIdentifier(importUrl, name);
 
   /// Create an expression of the form `prefix.Constructor(v1, v2, p3: v3)`.
   factory ConstExpression.constructor(String importUrl, String name,
-      List<ConstExpression> positionalArgs,
-      Map<String, ConstExpression> namedArgs) =>
+          List<ConstExpression> positionalArgs,
+          Map<String, ConstExpression> namedArgs) =>
       new ConstructorExpression(importUrl, name, positionalArgs, namedArgs);
 }
 
 /// A constant expression written as a String. Used when the code is self
 /// contained and it doesn't depend on any imported libraries.
 class CodeAsConstExpression extends ConstExpression {
   String code;
   List<String> get librariesUsed => const [];
 
   CodeAsConstExpression(this.code);
 
   String asCode(Map<String, String> libraryPrefixes) => code;
 
   String toString() => '(code: $code)';
-  operator== (other) => other is CodeAsConstExpression && code == other.code;
+  operator ==(other) => other is CodeAsConstExpression && code == other.code;
   int get hashCode => code.hashCode;
 }
 
 /// Describes a reference to some symbol that is exported from a library. This
 /// is typically used to refer to a type or a top-level variable from that
 /// library.
 class TopLevelIdentifier extends ConstExpression {
   final String importUrl;
   final String name;
   TopLevelIdentifier(this.importUrl, this.name);
 
   List<String> get librariesUsed => [importUrl];
   String asCode(Map<String, String> libraryPrefixes) {
     if (importUrl == 'dart:core' || importUrl == null) return name;
     return '${libraryPrefixes[importUrl]}.$name';
   }
 
   String toString() => '(identifier: $importUrl, $name)';
-  operator== (other) => other is TopLevelIdentifier && name == other.name
-      && importUrl == other.importUrl;
+  operator ==(other) => other is TopLevelIdentifier &&
+      name == other.name &&
+      importUrl == other.importUrl;
   int get hashCode => 31 * importUrl.hashCode + name.hashCode;
 }
 
 /// Represents an expression that invokes a const constructor.
 class ConstructorExpression extends ConstExpression {
   final String importUrl;
   final String name;
   final List<ConstExpression> positionalArgs;
   final Map<String, ConstExpression> namedArgs;
-  ConstructorExpression(this.importUrl, this.name, this.positionalArgs,
-      this.namedArgs);
+  ConstructorExpression(
+      this.importUrl, this.name, this.positionalArgs, this.namedArgs);
 
   List<String> get librariesUsed => [importUrl]
-      ..addAll(positionalArgs.expand((e) => e.librariesUsed))
-      ..addAll(namedArgs.values.expand((e) => e.librariesUsed));
+    ..addAll(positionalArgs.expand((e) => e.librariesUsed))
+    ..addAll(namedArgs.values.expand((e) => e.librariesUsed));
 
   String asCode(Map<String, String> libraryPrefixes) {
     var sb = new StringBuffer();
     sb.write('const ');
     if (importUrl != 'dart:core' && importUrl != null) {
       sb.write('${libraryPrefixes[importUrl]}.');
     }
     sb.write('$name(');
     bool first = true;
     for (var e in positionalArgs) {
       if (!first) sb.write(', ');
       first = false;
       sb.write(e.asCode(libraryPrefixes));
     }
     namedArgs.forEach((name, value) {
       if (!first) sb.write(', ');
       first = false;
       sb.write('$name: ');
       sb.write(value.asCode(libraryPrefixes));
     });
     sb.write(')');
     return sb.toString();
   }
 
   String toString() => '(ctor: $importUrl, $name, $positionalArgs, $namedArgs)';
-  operator== (other) => other is ConstructorExpression && name == other.name
-      && importUrl == other.importUrl &&
+  operator ==(other) => other is ConstructorExpression &&
+      name == other.name &&
+      importUrl == other.importUrl &&
       compareLists(positionalArgs, other.positionalArgs) &&
       compareMaps(namedArgs, other.namedArgs);
   int get hashCode => 31 * importUrl.hashCode + name.hashCode;
 }
 
-
 /// Describes a type identifier, with the library URL where the type is defined.
 // TODO(sigmund): consider adding support for imprecise TypeIdentifiers, which
 // may be used by tools that want to generate code without using the analyzer
 // (they can syntactically tell the type comes from one of N imports).
 class TypeIdentifier extends TopLevelIdentifier
     implements Comparable<TypeIdentifier> {
   final String comment;
   TypeIdentifier(importUrl, typeName, [this.comment])
       : super(importUrl, typeName);
 
   // We implement [Comparable] to sort out entries in the generated code.
   int compareTo(TypeIdentifier other) {
     if (importUrl == null && other.importUrl != null) return 1;
     if (importUrl != null && other.importUrl == null) return -1;
     var c1 = importUrl == null ? 0 : importUrl.compareTo(other.importUrl);
     return c1 != 0 ? c1 : name.compareTo(other.name);
   }
 
   String toString() => '(type-identifier: $importUrl, $name, $comment)';
   bool operator ==(other) => other is TypeIdentifier &&
-      importUrl == other.importUrl && name == other.name &&
+      importUrl == other.importUrl &&
+      name == other.name &&
       comment == other.comment;
   int get hashCode => super.hashCode;
 }
 
 /// Default set of imports added by [SmokeCodeGenerator].
 const DEFAULT_IMPORTS = const [
-    "import 'package:smoke/smoke.dart' show Declaration, PROPERTY, METHOD;",
-    "import 'package:smoke/static.dart' show "
-        "useGeneratedCode, StaticConfiguration;",
-  ];
+  "import 'package:smoke/smoke.dart' show Declaration, PROPERTY, METHOD;",
+  "import 'package:smoke/static.dart' show "
+      "useGeneratedCode, StaticConfiguration;",
+];
 
 _symbol(String name) {
   if (!_publicSymbolPattern.hasMatch(name)) {
     throw new StateError('invalid symbol name: "$name"');
   }
   return _literalSymbolPattern.hasMatch(name)
-      ? '#$name' : "const Symbol('$name')";
+      ? '#$name'
+      : "const Symbol('$name')";
 }
 
 // TODO(sigmund): is this included in some library we can import? I derived the
 // definitions below from sdk/lib/internal/symbol.dart.
 
 /// Reserved words in Dart.
 const String _reservedWordRE =
     r'(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|'
     r'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|'
     r'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|'
     r'v(?:ar|oid)|w(?:hile|ith))';
 
 /// Public identifier: a valid identifier (not a reserved word) that doesn't
 /// start with '_'.
 const String _publicIdentifierRE =
     r'(?!' '$_reservedWordRE' r'\b(?!\$))[a-zA-Z$][\w$]*';
 
 /// Pattern that matches operators only.
-final RegExp _literalSymbolPattern = new RegExp(
-    '^(?:$_publicIdentifierRE(?:\$|[.](?!\$)))+?\$');
+final RegExp _literalSymbolPattern =
+    new RegExp('^(?:$_publicIdentifierRE(?:\$|[.](?!\$)))+?\$');
 
 /// Operator names allowed as symbols. The name of the oeprators is the same as
 /// the operator itself except for unary minus, where the name is "unary-".
 const String _operatorRE =
     r'(?:[\-+*/%&|^]|\[\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
 
 /// Pattern that matches public symbols.
 final RegExp _publicSymbolPattern = new RegExp(
     '^(?:$_operatorRE\$|$_publicIdentifierRE(?:=?\$|[.](?!\$)))+?\$');