Add codegen support in smoke

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 @@
   final Map<Type, Type> parents;
 
   /// For each type, a map of declarations per symbol (property or method).
   final Map<Type, Map<Symbol, Declaration>> declarations;
 
   /// 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.names: const {}})
+      this.declarations: const {}, this.names: const {},
+      this.checkedMode: true})
       : this.symbols = {} {
     names.forEach((k, v) { symbols[v] = k; });
   }
 }
 
 /// Set up the smoke package to use a static implementation based on the given
 /// [configuration].
 useGeneratedCode(StaticConfiguration configuration) {
   _configuration = configuration;
   configure(new _GeneratedObjectAccessorService(),
@@ skipping 60 matching lines @@
 }
 
 /// Implements [TypeInspectorService] using a static configuration.
 class _GeneratedTypeInspectorService implements TypeInspectorService {
   bool isSubclassOf(Type type, Type supertype) {
     if (type == supertype || supertype == Object) return true;
     while (type != Object) {
       var parentType = _configuration.parents[type];
       if (parentType == supertype) return true;
       if (parentType == null) {
+        if (!_configuration.checkedMode) return false;
         throw new MissingCodeException('superclass of "$type" ($parentType)');
       }
       type = parentType;
     }
     return false;
   }
 
   bool hasGetter(Type type, Symbol name) {
     var decl = _findDeclaration(type, name);
     // No need to check decl.isProperty because methods are also automatically
     // considered getters (auto-closures).
     return decl != null && !decl.isStatic;
   }
 
   bool hasSetter(Type type, Symbol name) {
     var decl = _findDeclaration(type, name);
     return decl != null && !decl.isMethod && !decl.isFinal && !decl.isStatic;
   }
 
   bool hasInstanceMethod(Type type, Symbol name) {
     var decl = _findDeclaration(type, name);
     return decl != null && decl.isMethod && !decl.isStatic;
   }
 
   bool hasStaticMethod(Type type, Symbol name) {
     final map = _configuration.declarations[type];
     if (map == null) {
+      if (!_configuration.checkedMode) return false;
       throw new MissingCodeException('declarations for $type');
     }
     final decl = map[name];
     return decl != null && decl.isMethod && decl.isStatic;
   }
 
   Declaration getDeclaration(Type type, Symbol name) {
     var decl = _findDeclaration(type, name);
     if (decl == null) {
+      if (!_configuration.checkedMode) return null;
       throw new MissingCodeException('declaration for $type.$name');
     }
     return decl;
   }
 
   List<Declaration> query(Type type, QueryOptions options) {
-    var result;
+    var result = [];
     if (options.includeInherited) {
       var superclass = _configuration.parents[type];
       if (superclass == null) {
-        throw new MissingCodeException('superclass of "$type"');
+        if (_configuration.checkedMode) {
+          throw new MissingCodeException('superclass of "$type"');
+        }
+      } else if (superclass != options.includeUpTo) {
+        result = query(superclass, options);
       }
-      result = (superclass == options.includeUpTo) ? []
-          : query(superclass, options);
-    } else {
-      result = [];
     }
     var map = _configuration.declarations[type];
     if (map == null) {
+      if (!_configuration.checkedMode) return result;
       throw new MissingCodeException('declarations for $type');
     }
     for (var decl in map.values) {
       if (!options.includeFields && decl.isField) continue;
       if (!options.includeProperties && decl.isProperty) continue;
       if (options.excludeFinal && decl.isFinal) continue;
       if (!options.includeMethods && decl.isMethod) continue;
       if (options.withAnnotations != null &&
           !matchesAnnotation(decl.annotations, options.withAnnotations)) {
         continue;
@@ skipping 23 matching lines @@
 
 Declaration _findDeclaration(Type type, Symbol name) {
   while (type != Object) {
     final declarations = _configuration.declarations[type];
     if (declarations != null) {
       final declaration = declarations[name];
       if (declaration != null) return declaration;
     }
     var parentType = _configuration.parents[type];
     if (parentType == null) {
+      if (!_configuration.checkedMode) return null;
       throw new MissingCodeException('superclass of "$type"');
     }
     type = parentType;
   }
   return null;
 }