Converted Observatory instance-view element

runtime/observatory/lib/src/service/object.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.
 
 part of service;
 
 // Some value smaller than the object ring, so requesting a large array
 // doesn't result in an expired ref because the elements lapped it in the
 // object ring.
 const int kDefaultFieldLimit = 100;
@@ skipping 249 matching lines @@
         break;
       case 'Script':
         obj = new Script._empty(owner);
         break;
       case 'Socket':
         obj = new Socket._empty(owner);
         break;
       case 'Sentinel':
         obj = new Sentinel._empty(owner);
         break;
+      case 'TypeArguments':
+        obj = new TypeArguments._empty(owner);
+        break;
       case 'Instance':
         obj = new Instance._empty(owner);
         break;
       default:
         break;
     }
     if (obj == null) {
       obj = new ServiceMap._empty(owner);
     }
     obj.update(map);
@@ skipping 1076 matching lines @@
   }
 
   /// Builds the class hierarchy and returns the Object class.
   Future<Class> _buildClassHierarchy(List<Class> classes) {
     rootClasses.clear();
     objectClass = null;
     for (var cls in classes) {
       if (cls.superclass == null) {
         rootClasses.add(cls);
       }
-      if ((cls.vmName == 'Object') && (cls.isPatch == false)) {
+      if ((cls.vmName == 'Object') && (cls.isPatch == false)
+                                   && (cls.library.uri == 'dart:core')) {

[turnidge, 2016/08/30 21:31:16]

Odd indentation here... instead:

if (blah &&
    blah2 &&
    blah3) {

[cbernaschina, 2016/08/30 21:44:49]

Done.

         objectClass = cls;
       }
     }
     assert(objectClass != null);
     return new Future.value(objectClass);
   }
 
   Class getClassByCid(int cid) => _classesByCid[cid];
 
   ServiceObject getFromMap(ObservableMap map) {
@@ skipping 1202 matching lines @@
     : asSentinel = null;
 }
 
 class BoundField implements M.BoundField {
   final Field decl;
   final Guarded<Instance> value;
   BoundField(this.decl, value)
     : value = new Guarded(value);
 }
 
+class NativeField implements M.NativeField {
+  final int value;
+  NativeField(this.value);
+}
+
 class MapAssociation implements M.MapAssociation {
   final Guarded<Instance> key;
   final Guarded<Instance> value;
   MapAssociation(key, value)
     : key = new Guarded(key),
       value = new Guarded(value);
 }
 
 class Instance extends HeapObject implements M.Instance {
   @observable M.InstanceKind kind;
   @observable String valueAsString;  // If primitive.
   @observable bool valueAsStringIsTruncated;
   @observable ServiceFunction closureFunction;  // If a closure.
-  @observable Context context;  // If a closure.
+  @observable Context closureContext;  // If a closure.
   @observable int length; // If a List, Map or TypedData.
   int count;
   int offset;
   @observable Instance pattern;  // If a RegExp.
 
   @observable String name;
   @observable Class typeClass;
   @observable Class parameterizedClass;
-  @observable ServiceObject typeArguments;
+  @observable TypeArguments typeArguments;
   @observable int parameterIndex;
   @observable Instance targetType;
   @observable Instance bound;
 
   @observable Iterable<BoundField> fields;
   @observable var nativeFields;
   @observable Iterable<Guarded<HeapObject>> elements;  // If a List.
   @observable Iterable<MapAssociation> associations;  // If a Map.
   @observable Iterable<dynamic> typedElements;  // If a TypedData.
   @observable HeapObject referent;  // If a MirrorReference.
   @observable Instance key;  // If a WeakProperty.
   @observable Instance value;  // If a WeakProperty.
   @observable Breakpoint activationBreakpoint;  // If a Closure.
   @observable ServiceFunction oneByteFunction;  // If a RegExp.
   @observable ServiceFunction twoByteFunction;  // If a RegExp.
   @observable ServiceFunction externalOneByteFunction;  // If a RegExp.
   @observable ServiceFunction externalTwoByteFunction;  // If a RegExp.
   @observable Instance oneByteBytecode;  // If a RegExp.
   @observable Instance twoByteBytecode;  // If a RegExp.
   @observable bool isCaseSensitive;  // If a RegExp.
   @observable bool isMultiLine;  // If a RegExp.
 
-  bool get isAbstractType {
-    return (kind == M.InstanceKind.type ||
-            kind == M.InstanceKind.typeRef ||
-            kind == M.InstanceKind.typeParameter ||
-            kind == M.InstanceKind.boundedType);
-  }
+  bool get isAbstractType => M.isAbstractType(kind);
   bool get isNull => kind == M.InstanceKind.vNull;
   bool get isBool => kind == M.InstanceKind.bool;
   bool get isDouble => kind == M.InstanceKind.double;
   bool get isString => kind == M.InstanceKind.string;
   bool get isInt => kind == M.InstanceKind.int;
   bool get isList => kind == M.InstanceKind.list;
   bool get isMap => kind == M.InstanceKind.map;
   bool get isTypedData {
     return M.isTypedData(kind);
   }
@@ skipping 34 matching lines @@
   void _update(ObservableMap map, bool mapIsRef) {
     // Extract full properties.1
     _upgradeCollection(map, isolate);
     super._update(map, mapIsRef);
 
     kind = stringToInstanceKind(map['kind']);
     valueAsString = map['valueAsString'];
     // Coerce absence to false.
     valueAsStringIsTruncated = map['valueAsStringIsTruncated'] == true;
     closureFunction = map['closureFunction'];
-    context = map['closureContext'];
+    closureContext = map['closureContext'];
     name = map['name'];
     length = map['length'];
     pattern = map['pattern'];
     typeClass = map['typeClass'];
 
     if (mapIsRef) {
       return;
     }
 
     count = map['count'];
     offset = map['offset'];
     isCaseSensitive = map['isCaseSensitive'];
     isMultiLine = map['isMultiLine'];
     bool isCompiled = map['_oneByteFunction'] is ServiceFunction;
     oneByteFunction = isCompiled ? map['_oneByteFunction'] : null;
     twoByteFunction = isCompiled ? map['_twoByteFunction'] : null;
     externalOneByteFunction = isCompiled ? map['_externalOneByteFunction'] : null;
     externalTwoByteFunction = isCompiled ? map['_externalTwoByteFunction'] : null;
     oneByteBytecode = map['_oneByteBytecode'];
     twoByteBytecode = map['_twoByteBytecode'];
 
-    nativeFields = map['_nativeFields'];
     if (map['fields'] != null) {
       fields = map['fields']
         .map((f) => new BoundField(f['decl'], f['value'])).toList();
+    } else {
+      fields = null;
+    }
+    if (map['_nativeFields'] != null) {
+      nativeFields = map['_nativeFields']
+        .map((f) => new NativeField(f['value'])).toList();
+    } else {
+      nativeFields = null;
     }
     if (map['elements'] != null) {
     // Should be:
     // elements = map['elements'].map((e) => new Guarded<Instance>(e)).toList();
     // some times we obtain object that are not InstanceRef
       elements = map['elements'].map((e) => new Guarded<ServiceObject>(e))
         .toList();
+    } else {
+      elements = null;
     }
     if (map['associations'] != null) {
       associations = map['associations'].map((a) =>
           new MapAssociation(a['key'], a['value'])).toList();
+    } else {
+      associations = null;
     };
     if (map['bytes'] != null) {
       Uint8List bytes = BASE64.decode(map['bytes']);
       switch (map['kind']) {
         case "Uint8ClampedList":
           typedElements = bytes.buffer.asUint8ClampedList(); break;
         case "Uint8List":
           typedElements = bytes.buffer.asUint8List(); break;
         case "Uint16List":
           typedElements = bytes.buffer.asUint16List(); break;
@@ skipping 13 matching lines @@
           typedElements = bytes.buffer.asFloat32List(); break;
         case "Float64List":
           typedElements = bytes.buffer.asFloat64List(); break;
         case "Int32x4List":
           typedElements = bytes.buffer.asInt32x4List(); break;
         case "Float32x4List":
           typedElements = bytes.buffer.asFloat32x4List(); break;
         case "Float64x2List":
           typedElements = bytes.buffer.asFloat64x2List(); break;
       }
+    } else {
+      typedElements = null;
     }
     parameterizedClass = map['parameterizedClass'];
     typeArguments = map['typeArguments'];
     parameterIndex = map['parameterIndex'];
     targetType = map['targetType'];
     bound = map['bound'];
 
     referent = map['mirrorReferent'];
     key = map['propertyKey'];
     value = map['propertyValue'];
@@ skipping 924 matching lines @@
     dartOwner = map['_owner'];
     selector = map['_selector'];
     if (mapIsRef) {
       return;
     }
     argumentsDescriptor = map['_argumentsDescriptor'];
     entries = map['_entries'];
   }
 }
 
+class TypeArguments extends HeapObject implements M.TypeArguments {
+  HeapObject dartOwner;
+  String name;
+  Iterable<Instance> types;
+
+  TypeArguments._empty(ServiceObjectOwner owner) : super._empty(owner);
+
+  void _update(ObservableMap map, bool mapIsRef) {
+    _upgradeCollection(map, isolate);
+    super._update(map, mapIsRef);
+
+    dartOwner = map['_owner'];
+    name = map['name'];
+    if (mapIsRef) {
+      return;
+    }
+    types = map['types'];
+  }
+}
+
 class MegamorphicCache extends HeapObject implements M.MegamorphicCache {
   @observable int mask;
   @observable Instance buckets;
   @observable String selector;
   @observable Instance argumentsDescriptor;
 
   bool get immutable => false;
 
   MegamorphicCache._empty(ServiceObjectOwner owner) : super._empty(owner);
 
@@ skipping 664 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }