adds cast method

Author: itsjoeconway

lib/runtime.dart

@@ -6,14 +6,15 @@ import 'package:runtime/src/compiler.dart';
 import 'package:runtime/src/mirror_context.dart';
 
 export 'src/analyzer.dart';
-export 'package:runtime/src/context.dart';
+export 'src/context.dart';
 export 'src/build.dart';
 export 'src/compiler.dart';
 export 'src/file_system.dart';
 export 'src/generator.dart';
 export 'src/build_context.dart';
 export 'src/build_manager.dart';
 export 'src/mirror_context.dart';
+export 'src/exceptions.dart';
 
 /// Compiler for the runtime package itself.
 ///

lib/src/analyzer.dart

@@ -1,6 +1,3 @@
-import 'dart:io';
-
-import 'package:analyzer/dart/analysis/analysis_context.dart';
 import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ -43,7 +40,8 @@ class CodeAnalyzer {
       }
     }
 
-    throw ArgumentError("'uri' could not be resolved");
+    throw ArgumentError("'uri' could not be resolved (contexts: "
+        "${contexts.contexts.map((c) => c.contextRoot.root.toUri()).join(", ")})");
   }
 
   ClassDeclaration getClassFromFile(String className, Uri fileUri) {
@@ -70,8 +68,8 @@ class CodeAnalyzer {
 
     final unit = contexts.contextFor(path).currentSession.getParsedUnit(path);
     if (unit.errors.isNotEmpty) {
-      throw StateError(
-          "Project file '${path}' could not be analysed for the following reasons:\n\t${unit.errors.join("\n\t")}");
+      throw StateError("Project file '${path}' could not be analysed for the "
+          "following reasons:\n\t${unit.errors.join("\n\t")}");
     }
 
     return unit.unit;

lib/src/context.dart

@@ -31,6 +31,8 @@ abstract class RuntimeContext {
   /// `Subclass` must also have a runtime. The runtime objects for both `Subclass` and `Base`
   /// must be the same type.
   dynamic operator [](Type type) => runtimes[type];
+
+  T coerce<T>(dynamic input);
 }
 
 class RuntimeCollection {

lib/src/exceptions.dart

@@ -0,0 +1,12 @@
+class TypeCoercionException implements Exception {
+  TypeCoercionException(this.expectedType, this.actualType);
+
+  final Type expectedType;
+  final Type actualType;
+
+  @override
+  String toString({bool includeActualType = false}) {
+    final trailingString = includeActualType ? " (input is '$actualType')" : "";
+    return "input is not expected type '$expectedType'$trailingString";
+  }
+}

lib/src/mirror_coerce.dart

@@ -0,0 +1,72 @@
+import 'dart:mirrors';
+
+import 'package:runtime/src/exceptions.dart';
+
+dynamic runtimeCast(dynamic object, TypeMirror intoType) {
+  final exceptionToThrow =
+      TypeCoercionException(intoType.reflectedType, object.runtimeType as Type);
+
+  try {
+    final objectType = reflect(object).type;
+    if (objectType.isAssignableTo(intoType)) {
+      return object;
+    }
+
+    if (intoType.isSubtypeOf(reflectType(List))) {
+      if (object is! List) {
+        throw exceptionToThrow;
+      }
+
+      final elementType = intoType.typeArguments.first;
+      final elements = (object as List).map((e) => runtimeCast(e, elementType));
+      return (intoType as ClassMirror).newInstance(#from, [elements]).reflectee;
+    } else if (intoType.isSubtypeOf(reflectType(Map, [String, dynamic]))) {
+      if (object is! Map<String, dynamic>) {
+        throw exceptionToThrow;
+      }
+
+      final output = (intoType as ClassMirror)
+          .newInstance(const Symbol(""), []).reflectee as Map<String, dynamic>;
+      final valueType = intoType.typeArguments.last;
+      (object as Map<String, dynamic>).forEach((key, val) {
+        output[key] = runtimeCast(val, valueType);
+      });
+      return output;
+    }
+  } on TypeError {
+    throw exceptionToThrow;
+  } on CastError {
+    throw exceptionToThrow;
+  } on TypeCoercionException {
+    throw exceptionToThrow;
+  }
+
+  throw exceptionToThrow;
+}
+
+bool isTypeFullyPrimitive(TypeMirror type) {
+  if (type == reflectType(dynamic)) {
+    return true;
+  }
+
+  if (type.isSubtypeOf(reflectType(List))) {
+    return isTypeFullyPrimitive(type.typeArguments.first);
+  } else if (type.isSubtypeOf(reflectType(Map))) {
+    return isTypeFullyPrimitive(type.typeArguments.first) &&
+        isTypeFullyPrimitive(type.typeArguments.last);
+  }
+
+  if (type.isSubtypeOf(reflectType(num))) {
+    return true;
+  }
+
+  if (type.isSubtypeOf(reflectType(String))) {
+    return true;
+  }
+
+  if (type.isSubtypeOf(reflectType(bool))) {
+    return true;
+  }
+
+  return false;
+}

lib/src/mirror_context.dart

@@ -2,6 +2,7 @@ import 'dart:mirrors';
 
 import 'package:runtime/src/context.dart';
 import 'package:runtime/src/compiler.dart';
+import 'package:runtime/src/mirror_coerce.dart';
 
 RuntimeContext instance = MirrorContext._();
 
@@ -57,6 +58,11 @@ class MirrorContext extends RuntimeContext {
       return true;
     }).toList();
   }
+
+  @override
+  T coerce<T>(dynamic input) {
+    return runtimeCast(input, reflectType(T));
+  }
 }
 
 T firstMetadataOfType<T>(DeclarationMirror dm, {TypeMirror dynamicType}) {

lib/src/slow_coerce.dart

@@ -0,0 +1,67 @@
+import 'package:runtime/src/exceptions.dart';
+
+const String _listPrefix = "List<";
+const String _mapPrefix = "Map<String,";
+
+T cast<T>(dynamic input) {
+  if (input == null) {
+    return null;
+  }
+
+  try {
+    final typeString = T.toString();
+    if (typeString.startsWith(_listPrefix)) {
+      if (input is! List) {
+        throw TypeError();
+      }
+
+      if (typeString == "List<int>") {
+        return List<int>.from(input) as T;
+      } else if (typeString == "List<num>") {
+        return List<num>.from(input) as T;
+      } else if (typeString == "List<double>") {
+        return List<double>.from(input) as T;
+      } else if (typeString == "List<String>") {
+        return List<String>.from(input) as T;
+      } else if (typeString == "List<bool>") {
+        return List<bool>.from(input) as T;
+      } else if (typeString == "List<Map<String, dynamic>>") {
+        final objects = <Map<String, dynamic>>[];
+        (input as List).forEach((o) {
+          if (o == null) {
+            objects.add(null);
+          } else {
+            if (o is! Map<String, dynamic>) {
+              throw TypeError();
+            }
+            objects.add(o);
+          }
+        });
+        return objects as T;
+      }
+    } else if (typeString.startsWith(_mapPrefix)) {
+      if (input is! Map) {
+        throw TypeError();
+      }
+
+      final inputMap = input as Map<String, dynamic>;
+      if (typeString == "Map<String, int>") {
+        return Map<String, int>.from(inputMap) as T;
+      } else if (typeString == "Map<String, num>") {
+        return Map<String, num>.from(inputMap) as T;
+      } else if (typeString == "Map<String, double>") {
+        return Map<String, double>.from(inputMap) as T;
+      } else if (typeString == "Map<String, String>") {
+        return Map<String, String>.from(inputMap) as T;
+      } else if (typeString == "Map<String, bool>") {
+        return Map<String, bool>.from(inputMap) as T;
+      }
+    }
+
+    return input as T;
+  } on CastError {
+    throw TypeCoercionException(T, input.runtimeType as Type);
+  } on TypeError {
+    throw TypeCoercionException(T, input.runtimeType as Type);
+  }
+}

pubspec.yaml

@@ -1,6 +1,6 @@
 name: runtime
 description: Provides behaviors and base types for packages that can use mirrors and be AOT compiled.
-version: 1.0.0-7
+version: 1.0.0-8
 author: Joe Conway <[email protected]>
 homepage: https://stablekernel.com