Add support in smoke for generating static configurations in pieces.

pkg/smoke/lib/static.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.
 
 /// Static implementation of smoke services using code-generated data.
 library smoke.static;
 
 import 'dart:math' as math;
 
 import 'package:logging/logging.dart';
@@ skipping 19 matching lines @@
   /// For each type, a map of declarations per symbol (property or method).
   final Map<Type, Map<Symbol, Declaration>> declarations;
 
   /// Static methods for each type.
   // TODO(sigmund): should we add static getters & setters too?
   final Map<Type, Map<Symbol, Function>> staticMethods;
 
   /// A map from symbol to strings.
   final Map<Symbol, String> names;
 
+  /// A map from strings to symbols (the reverse of [names]).
+  final Map<String, Symbol> _symbols = {};
+
+
   /// Whether to check for missing declarations, otherwise, return default
   /// values (for example a missing parent class can be treated as Object)
   final bool checkedMode;
 
   StaticConfiguration({
-      this.getters: const {}, this.setters: const {}, this.parents: const {},
-      this.declarations: const {}, this.staticMethods: const {},
-      this.names: const {}, this.checkedMode: true});
+      Map<Symbol, Getter> getters,
+      Map<Symbol, Setter> setters,
+      Map<Type, Type> parents,
+      Map<Type, Map<Symbol, Declaration>> declarations,
+      Map<Type, Map<Symbol, Function>> staticMethods,
+      Map<Symbol, String> names,
+      this.checkedMode: true})
+      : getters = getters != null ? getters : {},
+        setters = setters != null ? setters : {},
+        parents = parents != null ? parents : {},
+        declarations = declarations != null ? declarations : {},
+        staticMethods = staticMethods != null ? staticMethods : {},
+        names = names != null ? names : {} {
+    this.names.forEach((k, v) { _symbols[v] = k; });
+  }
+
+  void addAll(StaticConfiguration other) {
+    getters.addAll(other.getters);
+    setters.addAll(other.setters);
+    parents.addAll(other.parents);
+    _nestedAddAll(declarations, other.declarations);
+    _nestedAddAll(staticMethods, other.staticMethods);
+    names.addAll(other.names);
+    other.names.forEach((k, v) { _symbols[v] = k; });
+  }
+
+  static _nestedAddAll(Map a, Map b) {
+    for (var key in b.keys) {
+      a.putIfAbsent(key, () => {});

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

So is this not inserting a null? It seems like there must be some magic going on
where its inserting a new object using the default constructor? Or maybe I am
just missing something here.

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

Yeah, it's confusing because we have both => and {}, the {} here is an empty
map. To be more precise:

() {}      // returns null
() => null // equivalent closure.
() => {}   // returns a new map :-)

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

haha tricky, I figured it had to be something I was missing.

+      a[key].addAll(b[key]);
+    }
+  }
 }
 
 /// Set up the smoke package to use a static implementation based on the given
 /// [configuration].
 useGeneratedCode(StaticConfiguration configuration) {
   configure(new GeneratedObjectAccessorService(configuration),
       new GeneratedTypeInspectorService(configuration),
       new GeneratedSymbolConverterService(configuration));
 }
 
 /// Implements [ObjectAccessorService] using a static configuration.
 class GeneratedObjectAccessorService implements ObjectAccessorService {
-  final Map<Symbol, Getter> _getters;
-  final Map<Symbol, Setter> _setters;
-  final Map<Type, Map<Symbol, Function>> _staticMethods;
+  final StaticConfiguration _configuration;
+  Map<Symbol, Getter> get _getters => _configuration.getters;
+  Map<Symbol, Setter> get _setters => _configuration.setters;
+  Map<Type, Map<Symbol, Function>> get _staticMethods =>
+      _configuration.staticMethods;
 
-  GeneratedObjectAccessorService(StaticConfiguration configuration)
-      : _getters = configuration.getters,
-        _setters = configuration.setters,
-        _staticMethods = configuration.staticMethods;
+  GeneratedObjectAccessorService(this._configuration);
 
   read(Object object, Symbol name) {
     var getter = _getters[name];
     if (getter == null) {
       throw new MissingCodeException('getter "$name" in $object');
     }
     return getter(object);
   }
 
   void write(Object object, Symbol name, value) {
@@ skipping 42 matching lines @@
       // we should wrap `e` as a new exception (what's the best way to let users
       // know about this tentativeError?)
       if (tentativeError != null) print(tentativeError);
       rethrow;
     }
   }
 }
 
 /// Implements [TypeInspectorService] using a static configuration.
 class GeneratedTypeInspectorService implements TypeInspectorService {
-  final Map<Type, Type> _parents;
-  final Map<Type, Map<Symbol, Declaration>> _declarations;
-  final bool _checkedMode;
+  final StaticConfiguration _configuration;
 
-  GeneratedTypeInspectorService(StaticConfiguration configuration)
-      : _parents = configuration.parents,
-        _declarations = configuration.declarations,
-        _checkedMode = configuration.checkedMode;
+  Map<Type, Type> get _parents => _configuration.parents;
+  Map<Type, Map<Symbol, Declaration>> get _declarations =>
+      _configuration.declarations;
+  bool get _checkedMode => _configuration.checkedMode;
+
+  GeneratedTypeInspectorService(this._configuration);
+
   bool isSubclassOf(Type type, Type supertype) {
     if (type == supertype || supertype == Object) return true;
     while (type != Object) {
       var parentType = _parents[type];
       if (parentType == supertype) return true;
       if (parentType == null) {
         if (!_checkedMode) return false;
         throw new MissingCodeException('superclass of "$type" ($parentType)');
       }
       type = parentType;
@@ skipping 82 matching lines @@
         throw new MissingCodeException('superclass of "$type"');
       }
       type = parentType;
     }
     return null;
   }
 }
 
 /// Implements [SymbolConverterService] using a static configuration.
 class GeneratedSymbolConverterService implements SymbolConverterService {
-  Map<Symbol, String> _names;
+  final StaticConfiguration _configuration;
+  Map<Symbol, String> get _names => _configuration.names;
+  Map<String, Symbol> get _symbols => _configuration._symbols;
 
-  /// A map from strings to symbols (the reverse of [names]).
-  final Map<String, Symbol> _symbols;
-
-  GeneratedSymbolConverterService(StaticConfiguration configuration)
-      : _names = configuration.names,
-        _symbols = {} {
-    _names.forEach((k, v) { _symbols[v] = k; });
-  }
+  GeneratedSymbolConverterService(this._configuration);
 
   String symbolToName(Symbol symbol) => _names[symbol];
   Symbol nameToSymbol(String name) => _symbols[name];
 }
 
 
 /// Exception thrown when trynig to access something that should be there, but
 /// the code generator didn't include it.
 class MissingCodeException implements Exception {
   final String description;
   MissingCodeException(this.description);
 
   String toString() => 'Missing $description. '
       'Code generation for the smoke package seems incomplete.';
 }