Add support in smoke for generating static configurations in pieces.

pkg/smoke/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.
 library smoke.codegen.generator;
 
 import 'dart:collection' show SplayTreeMap, SplayTreeSet;
 
 import 'package:smoke/src/common.dart' show compareLists, compareMaps;
 
 /// Collects the necessary information and generates code to initialize a
 /// `StaticConfiguration`. After setting up the generator by calling
 /// [addGetter], [addSetter], [addSymbol], and [addDeclaration], you can
 /// retrieve the generated code using the following three methods:
 ///
 ///   * [writeImports] writes a list of imports directives,
 ///   * [writeTopLevelDeclarations] writes additional declarations used to
 ///     represent mixin classes by name in the generated code.
-///   * [writeInitCall] writes the actual code that allocates the static
-///     configuration.
+///   * [writeStaticConfiguration] writes the actual code that allocates the
+///     static configuration.
 ///
 /// You'd need to include all three in your generated code, since the
 /// initialization code refers to symbols that are only available from the
 /// generated imports or the generated top-level declarations.
 class SmokeCodeGenerator {
   // Note: we use SplayTreeSet/Map here and below to keep generated code sorted.
   /// Names used as getters via smoke.
   final Set<String> _getters = new SplayTreeSet();
 
   /// Names used as setters via smoke.
@@ skipping 89 matching lines @@
   /// 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>());
   }
 
   /// Writes to [buffer] a line for each import that is needed by the generated
-  /// code. The code added by [writeInitCall] depends on these imports.
+  /// 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 [writeInitCall]. These are typically declarations of empty
-  /// classes that are then used as placeholders for mixin superclasses.
+  /// 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);
     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 initialize smoke's static
-  /// configuration. For example, the code might be of the form:
+  /// Appends to [buffer] code that will create smoke's static configuration.
+  /// For example, the code might be of the form:
   ///
-  ///    useGeneratedCode(new StaticConfiguration(
+  ///    new StaticConfiguration(
   ///      getters: {
   ///         #i: (o) => o.i,
   ///         ...
   ///      names: {
   ///         #i: "i",
-  ///      }));
+  ///      })
+  ///
+  /// Callers of this code can assign this expression to a variable, and should
+  /// generate code that invokes `useGeneratedCode`.
   ///
   /// The optional [indent] argument is used for formatting purposes. All
   /// entries in each map (getters, setters, names, declarations, parents) are
   /// sorted alphabetically.
   ///
   /// **Note**: this code assumes that imports from [writeImports] and top-level
   /// declarations from [writeTopLevelDeclarations] are included in the same
   /// library where this code will live.
-  void writeInitCall(StringBuffer buffer, [int indent = 2]) {
-    final spaces = new List.filled(indent, ' ').join('');
+  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; }');
     }
 
     if (_parents.isNotEmpty) {
       var parentsMap = [];
       _parents.forEach((child, parent) {
         var parent = _parents[child];
         parentsMap.add('${child.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(': ');
         if (members.isEmpty) {
-          sb.write('const {}');
+          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}    ${_symbol(name)}: $decl,\n');
           });
-          sb.write('$spaces      }');
+          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(': ');
         if (members.isEmpty) {
-          sb.write('const {}');
+          sb.write('{}');
         } else {
           sb.write('{\n');
           for (var name in members) {
-            sb.write('$spaces        ${_symbol(name)}: $className.$name,\n');
+            sb.write('${spaces}    ${_symbol(name)}: $className.$name,\n');
           }
-          sb.write('$spaces      }');
+          sb.write('${spaces}  }');
         }
         methods.add(sb.toString());
       });
       args['staticMethods'] = methods;
     }
 
     if (_names.isNotEmpty) {
       args['names'] = _names.map((n) => "${_symbol(n)}: r'$n'");
     }
 
-    buffer..write(spaces)
-        ..writeln('useGeneratedCode(new StaticConfiguration(')
-        ..write('$spaces    checkedMode: false');
+    buffer..writeln('new StaticConfiguration(')
+        ..write('${spaces}checkedMode: false');

[jakemac, 2014/07/23 20:05:02]

I think technically these ..'s should line up

[Siggi Cherem (dart-lang), 2014/07/23 20:37:13]

we have debated a bit about it in the past - the styleguide requires +4 spaces
of indentation and optionally extra spaces to line things up, but so far we have
preferred to keep it with just +4.

[jakemac, 2014/07/23 20:40:51]

Acknowledged.

 
     args.forEach((name, mapContents) {
       buffer.writeln(',');
       // TODO(sigmund): use const map when Type can be keys (dartbug.com/17123)
-      buffer.writeln('$spaces    $name: {');
+      buffer.writeln('${spaces}$name: {');
       for (var entry in mapContents) {
-        buffer.writeln('$spaces      $entry,');
+        buffer.writeln('${spaces}  $entry,');
       }
-      buffer.write('$spaces    }');
+      buffer.write('${spaces}}');
     });
-    buffer.writeln('));');
+    buffer.write(')');
   }
 
   /// Adds a library that needs to be imported.
   void _addLibrary(String url) {
     if (url == null || url == 'dart:core') return;
     _libraryPrefix.putIfAbsent(url, () => 'smoke_${_libraryPrefix.length}');
   }
 }
 
 /// Information used to generate code that allocates a `Declaration` object.
@@ skipping 214 matching lines @@
     '^(?:$_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(?:=?\$|[.](?!\$)))+?\$');