rename ddc -> dev_compiler, fixes #84

lib/runtime/dart_logging_runtime.dart

 // Copyright (c) 2015, 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 ddc.runtime.dart_logging_runtime;
+library dev_compiler.runtime.dart_logging_runtime;
 
 import 'dart:mirrors' as mirrors;
 
 import 'dart_runtime.dart' as rt;
 export 'dart_runtime.dart' show Arity, getArity, type;
 
 import 'package:stack_trace/stack_trace.dart';
 
 // Logging / updating CastRecords for cases that alway pass in Dart and DDC
 // is expensive.  They are also less interesting, so filter out by default.
 const bool _skipSuccess = true;
 
 class CastRecord {
   final Type runtimeType;
   final Type staticType;
-  final bool ddcSuccess;
-  final bool dartSuccess;
 
-  CastRecord(
-      this.runtimeType, this.staticType, this.ddcSuccess, this.dartSuccess);
+  /// True if the dev_compiler would allow this cast. Otherwise false.
+  final bool soundCast;
+
+  /// True if Dart checked mode would allow this cast. Otherwise false.
+  final bool dartCast;
+
+  CastRecord(this.runtimeType, this.staticType, this.soundCast, this.dartCast);
 }
 
 // Register a handler to process CastRecords.  The default (see below) just
 // prints a summary at the end.
 typedef void CastRecordHandler(String key, CastRecord record);
 CastRecordHandler castRecordHandler = _record;
 
 var _cache = <Type, Map<Type, CastRecord>>{};
 
 Map<Type, CastRecord> _cacheGen() => <Type, CastRecord>{};
@@ skipping 22 matching lines @@
 
   if (key == null) {
     // If no key is past in, use the caller's frame as a key.
     final trace = new Trace.current(1);
     final frame = trace.frames.first;
     key = frame.toString();
   }
 
   CastRecord record = _lookupInCache(runtimeType, staticType);
   if (record == null) {
-    bool ddcSuccess = true;
-    bool dartSuccess = true;
+    bool soundCast = true;
+    bool dartCast = true;
     // TODO(vsm): Use instanceOf once we settle on nullability.
     try {
       rt.cast(obj, staticType);
     } catch (e) {
-      ddcSuccess = false;
+      soundCast = false;
     }
     if (obj == null) {
-      dartSuccess = true;
+      dartCast = true;
     } else {
       // TODO(vsm): We could avoid mirror code by requiring the caller to pass
       // in obj is TypeLiteral as a parameter.  We can't do that once we have a
       // Type object instead.
       final staticMirror = mirrors.reflectType(staticType);
       final instanceMirror = mirrors.reflect(obj);
       final classMirror = instanceMirror.type;
-      dartSuccess = classMirror.isSubtypeOf(staticMirror);
+      dartCast = classMirror.isSubtypeOf(staticMirror);
     }
-    if (_skipSuccess && dartSuccess && ddcSuccess) {
+    if (_skipSuccess && dartCast && soundCast) {
       _successCache
           .putIfAbsent(staticType, () => new Set<Type>())
           .add(runtimeType);
       return obj;
     }
-    record = new CastRecord(runtimeType, staticType, ddcSuccess, dartSuccess);
+    record = new CastRecord(runtimeType, staticType, soundCast, dartCast);
     _addToCache(runtimeType, staticType, record);
   }
   castRecordHandler(key, record);
   return obj;
 }
 
 dynamic wrap(Function build(Function _), Function f, Type fromType, Type toType,
     String kind, String key, bool dartIs) {
   if (f == null) return null;
   return build(f);
@@ skipping 16 matching lines @@
     Type staticType = null;
     var runtimeTypes = new Set<Type>();
     for (var record in records) {
       if (staticType == null) {
         staticType = record.staticType;
       } else {
         // Are these canonicalized?
         // assert(staticType == record.staticType);
       }
       runtimeTypes.add(record.runtimeType);
-      if (record.ddcSuccess) {
-        if (record.dartSuccess) {
+      if (record.soundCast) {
+        if (record.dartCast) {
           success++;
         } else {
           error++;
         }
       } else {
-        if (record.dartSuccess) {
+        if (record.dartCast) {
           mismatch++;
         } else {
           failure++;
         }
       }
     }
     final total = success + mismatch + error + failure;
     assert(total != 0);
     if (success < total) {
       buffer.writeln('Key $key:');
       buffer.writeln(' - static type: $staticType');
       buffer.writeln(' - runtime types: $runtimeTypes');
       final category = (String cat, int val) =>
           buffer.writeln(' - $cat: $val (${val / total})');
       category('success', success);
       category('failure', failure);
       category('mismatch', mismatch);
       category('error', error);
     }
   });
   if (clear) {
     _recordMap.clear();
   }
   return buffer.toString();
 }