Changes in smoke in preparation of polymer's codegen:

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.
@@ skipping 242 matching lines @@
     }
     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 &&
       isStatic == other.isStatic &&
-      _compareLists(annotations, other.annotations);
+      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.
   List<String> get librariesUsed;
 
@@ skipping 89 matching lines @@
       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 &&
-      _compareLists(positionalArgs, other.positionalArgs) &&
-      _compareMaps(namedArgs, other.namedArgs);
+      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> {
@@ skipping 15 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;",
   ];
-
-/// Shallow comparison of two lists.
-bool _compareLists(List a, List b) {
-  if (a == null && b != null) return false;
-  if (a != null && b == null) return false;
-  if (a.length != b.length) return false;
-  for (int i = 0; i < a.length; i++) {
-    if (a[i] != b[i]) return false;
-  }
-  return true;
-}
-
-/// Shallow comparison of two maps.
-bool _compareMaps(Map a, Map b) {
-  if (a == null && b != null) return false;
-  if (a != null && b == null) return false;
-  if (a.length != b.length) return false;
-  for (var k in a.keys) {
-    if (!b.containsKey(k) || a[k] != b[k]) return false;
-  }
-  return true;
-}