More features for ConstantReader (#180)

* Add a Constant helper class.

* Add List and Map.

* Add missing field handling.

* Oops.

* Fix tests.

Author: matanlurey

lib/src/constants.dart

@@ -3,6 +3,25 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/constant/value.dart';
+import 'package:analyzer/dart/element/element.dart';
+
+/// Throws an exception if [root] or its super(s) does not contain [name].
+void _assertHasField(ClassElement root, String name) {
+  var element = root;
+  while (element != null) {
+    final field = element.getField(name);
+    if (field != null) {
+      return;
+    }
+    element = element.supertype?.element;
+  }
+  final allFields = root.fields.toSet();
+  root.allSupertypes.forEach((t) => allFields.addAll(t.element.fields));
+  throw new FormatException(
+    'Class ${root.name} does not have field "$name".',
+    'Fields: $allFields',
+  );
+}
 
 /// Returns whether or not [object] is or represents a `null` value.
 bool _isNull(DartObject object) => object?.isNull != false;
@@ -43,6 +62,26 @@ abstract class ConstantReader {
   /// Throws [FormatException] if [isInt] is `false`.
   int get intValue;
 
+  /// Returns whether this constant represents a `List` literal.
+  ///
+  /// If `true`, [listValue] will return a `List` (not throw).
+  bool get isList;
+
+  /// Returns this constant as a `List` value.
+  ///
+  /// Throws [FormatException] if [isList] is `false`.
+  List<DartObject> get listValue;
+
+  /// Returns whether this constant represents a `Map` literal.
+  ///
+  /// If `true`, [listValue] will return a `Map` (not throw).
+  bool get isMap;
+
+  /// Returns this constant as a `Map` value.
+  ///
+  /// Throws [FormatException] if [isMap] is `false`.
+  Map<DartObject, DartObject> get mapValue;
+
   /// Returns whether this constant represents a `String` literal.
   ///
   /// If `true`, [stringValue] will return a `String` (not throw).
@@ -60,33 +99,49 @@ abstract class ConstantReader {
   ConstantReader read(String field);
 }
 
+dynamic _throw(String expected, [dynamic object]) {
+  throw new FormatException('Not a $expected', '$object');
+}
+
 /// Implements a [ConstantReader] representing a `null` value.
 class _NullConstant implements ConstantReader {
   const _NullConstant();
 
   @override
-  bool get boolValue => throw new FormatException('Not a bool', 'null');
+  bool get boolValue => _throw('bool');
+
+  @override
+  int get intValue => _throw('int');
+
+  @override
+  String get stringValue => _throw('String');
 
   @override
-  int get intValue => throw new FormatException('Not an int', 'null');
+  List<DartObject> get listValue => _throw('List');
 
   @override
-  String get stringValue => throw new FormatException('Not a String', 'null');
+  Map<DartObject, DartObject> get mapValue => _throw('Map');
 
   @override
   bool get isBool => false;
 
   @override
   bool get isInt => false;
 
+  @override
+  bool get isList => false;
+
+  @override
+  bool get isMap => false;
+
   @override
   bool get isNull => true;
 
   @override
   bool get isString => false;
 
   @override
-  ConstantReader read(_) => this;
+  ConstantReader read(_) => throw new UnsupportedError('Null');
 }
 
 /// Default implementation of [ConstantReader].
@@ -96,33 +151,51 @@ class _Constant implements ConstantReader {
   const _Constant(this._object);
 
   @override
-  bool get boolValue => isBool
-      ? _object.toBoolValue()
-      : throw new FormatException('Not a bool', _object);
+  bool get boolValue =>
+      isBool ? _object.toBoolValue() : _throw('bool', _object);
+
+  @override
+  int get intValue => isInt ? _object.toIntValue() : _throw('int', _object);
+
+  @override
+  String get stringValue =>
+      isString ? _object.toStringValue() : _throw('String', _object);
 
   @override
-  int get intValue => isInt
-      ? _object.toIntValue()
-      : throw new FormatException('Not an int', _object);
+  List<DartObject> get listValue =>
+      isList ? _object.toListValue() : _throw('List', _object);
 
   @override
-  String get stringValue => isString
-      ? _object.toStringValue()
-      : throw new FormatException('Not a String', _object);
+  Map<DartObject, DartObject> get mapValue =>
+      isMap ? _object.toMapValue() : _throw('Map', _object);
 
   @override
   bool get isBool => _object.toBoolValue() != null;
 
   @override
   bool get isInt => _object.toIntValue() != null;
 
+  @override
+  bool get isList => _object?.toListValue() != null;
+
   @override
   bool get isNull => _isNull(_object);
 
+  @override
+  bool get isMap => _object?.toMapValue() != null;
+
   @override
   bool get isString => _object.toStringValue() != null;
 
   @override
-  ConstantReader read(String field) =>
-      new ConstantReader(_getFieldRecursive(_object, field));
+  ConstantReader read(String field) {
+    final constant = new ConstantReader(_getFieldRecursive(_object, field));
+    if (constant.isNull) {
+      _assertHasField(_object?.type?.element, field);
+    }
+    return constant;
+  }
+
+  @override
+  String toString() => 'ConstantReader ${_object}';
 }

pubspec.yaml

@@ -8,12 +8,12 @@ environment:
 dependencies:
   analyzer: '>=0.29.2 <0.31.0'
   build: ^0.9.0
+  collection: ^1.1.2
   dart_style: '>=0.1.7 <2.0.0'
   path: ^1.3.2
 dev_dependencies:
   build_runner: ^0.3.2
   build_test: ^0.6.0
   cli_util: '>=0.0.1 <0.2.0'
-  collection: ^1.1.2
   mockito: '>=0.11.0 <3.0.0'
   test: ^0.12.3

test/constants_test.dart

@@ -2,7 +2,9 @@
 // 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.
 
+import 'package:analyzer/dart/constant/value.dart';
 import 'package:build_test/build_test.dart';
+import 'package:collection/collection.dart';
 import 'package:source_gen/source_gen.dart';
 import 'package:test/test.dart';
 
@@ -18,6 +20,8 @@ void main() {
         const aInt = 1234;
         const aBool = true;
         const aNull = null;
+        const aList = const [1, 2, 3];
+        const aMap = const {1: 'A', 2: 'B'};
         
         @aString    // [0]
         @aInt       // [1]
@@ -28,9 +32,11 @@ void main() {
           aInt: aInt,
           aBool: aBool,
           aNull: aNull,
-          nested: const Exampe(),
+          nested: const Example(),
         )
         @Super()    // [5]
+        @aList      // [6]
+        @aMap       // [7]
         class Example {
           final String aString;
           final int aInt;
@@ -76,9 +82,9 @@ void main() {
       expect(constant.read('aString').stringValue, 'Hello');
       expect(constant.read('aInt').intValue, 1234);
       expect(constant.read('aBool').boolValue, true);
-      expect(constant.read('aNull').isNull, isTrue);
 
       final nested = constant.read('nested');
+      expect(nested.isNull, isFalse, reason: '$nested');
       expect(nested.read('aString').isNull, isTrue);
       expect(nested.read('aInt').isNull, isTrue);
       expect(nested.read('aBool').isNull, isTrue);
@@ -88,5 +94,31 @@ void main() {
       final constant = constants[5];
       expect(constant.read('aString').stringValue, 'Super Hello');
     });
+
+    test('should read a list', () {
+      expect(constants[6].isList, isTrue, reason: '${constants[6]}');
+      expect(constants[6].listValue.map((c) => new ConstantReader(c).intValue),
+          [1, 2, 3]);
+    });
+
+    test('should read a map', () {
+      expect(constants[7].isMap, isTrue, reason: '${constants[7]}');
+      expect(
+          mapMap<DartObject, DartObject, int, String>(constants[7].mapValue,
+              key: (k, _) => new ConstantReader(k).intValue,
+              value: (_, v) => new ConstantReader(v).stringValue),
+          {1: 'A', 2: 'B'});
+    });
+
+    test('should fail reading from `null`', () {
+      final $null = constants[3];
+      expect($null.isNull, isTrue, reason: '${$null}');
+      expect(() => $null.read('foo'), throwsUnsupportedError);
+    });
+
+    test('should fail reading a missing field', () {
+      final $super = constants[5];
+      expect(() => $super.read('foo'), throwsFormatException);
+    });
   });
 }