Fix string literals and add support for static methods in smoke.

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.
@@ skipping 25 matching lines @@
   /// Names used as setters via smoke.
   final Set<String> _setters = new SplayTreeSet();
 
   /// Subclass relations needed to run smoke queries.
   final Map<TypeIdentifier, TypeIdentifier> _parents = new SplayTreeMap();
 
   /// Declarations requested via `smoke.getDeclaration or `smoke.query`.
   final Map<TypeIdentifier, Map<String, _DeclarationCode>> _declarations =
       new SplayTreeMap();
 
+  /// 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); }
 
   /// Register that [name] is used as a setter in the code.
   void addSetter(String name) { _setters.add(name); }
 
   /// Register that [name] might be needed as a symbol.
   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>());
+    _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);
 
   /// Register that we care to know that [child] extends [parent].
   void addParent(TypeIdentifier child, TypeIdentifier parent) {
     var existing = _parents[child];
@@ skipping 130 matching lines @@
             var decl = members[name].asCode(_libraryPrefix);
             sb.write('$spaces        #$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(': ');
+        if (members.isEmpty) {
+          sb.write('const {}');
+        } else {
+          sb.write('{\n');
+          for (var name in members) {
+            sb.write('$spaces        #$name: $className.$name,\n');
+          }
+          sb.write('$spaces      }');
+        }
+        methods.add(sb.toString());
+      });
+      args['staticMethods'] = methods;
+    }
+
     if (_names.isNotEmpty) {
-      args['names'] = _names.map((n) => "#$n: '$n'");
+      args['names'] = _names.map((n) => "#$n: r'$n'");
     }
 
     buffer..write(spaces)
         ..writeln('useGeneratedCode(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: {');
@@ skipping 193 matching lines @@
       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;",
   ];