Added `dynamicReflected..Type`, corrected type expressions.

reflectable/lib/src/transformer_implementation.dart

 // (c) 2015, the Dart Team. All rights reserved. Use of this
 // source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
 library reflectable.src.transformer_implementation;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:developer' as developer;
 import 'dart:io';
@@ skipping 797 matching lines @@
     Iterable<String> membersList = () sync* {
       yield* topLevelVariablesList;
       yield* fieldsList;
       yield* methodsList;
     }();
     String membersCode = _formatAsList("m.DeclarationMirror", membersList);
 
     // Generate code for listing [Type] instances.
     String typesCode =
         _formatAsConstList("Type", classes.map((ClassElement classElement) {
-      return _typeCodeOfClass(classElement, importCollector);
+      return _dynamicTypeCodeOfClass(classElement, importCollector);
     }));
 
     // Generate code for creation of library mirrors.
     String librariesCode;
     if (!_capabilities._supportsLibraries) {
       librariesCode = "null";
     } else {
       librariesCode = _formatAsList("m.LibraryMirror",
           libraries.items.map((_LibraryDomain library) {
         return _libraryMirrorCode(library, libraries.indexOf(library), members,
@@ skipping 303 matching lines @@
       if (_capabilities._impliesDeclarations) {
         int indexOf(TypeParameterElement typeParameter) =>
             typeParameters.indexOf(typeParameter) + typeParametersOffset;
         typeParameterIndices = _formatAsConstList(
             'int',
             classElement.typeParameters
                 .where(typeParameters.items.contains)
                 .map(indexOf));
       }
 
+      String dynamicReflectedTypeCode =
+          "${importCollector._getPrefix(classElement.library)}"
+          "${classElement.name}";
+
       return 'new r.GenericClassMirrorImpl(r"${classDomain._simpleName}", '
           'r"${_qualifiedName(classElement)}", $descriptor, $classIndex, '
           '${_constConstructionCode(importCollector)}, '
           '$declarationsCode, $instanceMembersCode, $staticMembersCode, '
           '$superclassIndex, $staticGettersCode, $staticSettersCode, '
           '$constructorsCode, $ownerIndex, $mixinIndex, '
           '$superinterfaceIndices, $classMetadataCode, $isCheckCode, '
-          '$typeParameterIndices)';
+          '$typeParameterIndices, $dynamicReflectedTypeCode)';
     }
   }
 
   String _methodMirrorCode(
       ExecutableElement element,
       Enumerator<TopLevelVariableElement> topLevelVariables,
       Enumerator<FieldElement> fields,
       Enumerator<ExecutableElement> members,
       Enumerator<ParameterElement> parameters,
       _ImportCollector importCollector,
       TransformLogger logger,
       bool reflectedTypeRequested) {
     if (element is PropertyAccessorElement && element.isSynthetic) {
       // There is no type propagation, so we declare an `accessorElement`.
       PropertyAccessorElement accessorElement = element;
       PropertyInducingElement variable = accessorElement.variable;
       int variableMirrorIndex = variable is TopLevelVariableElement
           ? topLevelVariables.indexOf(variable)
           : fields.indexOf(variable);
       String reflectedTypeCode = reflectedTypeRequested
           ? _typeCode(accessorElement.variable.type, importCollector)
           : "null";
+      String dynamicReflectedTypeCode = reflectedTypeRequested
+          ? _dynamicTypeCodeOrNull(
+              accessorElement.variable.type, importCollector)
+          : "null";
       // The `indexOf` is non-null: `accessorElement` came from `members`.
       int selfIndex = members.indexOf(accessorElement) + fields.length;
       if (accessorElement.isGetter) {
         return 'new r.ImplicitGetterMirrorImpl('
             '${_constConstructionCode(importCollector)}, '
-            '$variableMirrorIndex, $reflectedTypeCode, $selfIndex)';
+            '$variableMirrorIndex, $reflectedTypeCode, '
+            '$dynamicReflectedTypeCode, $selfIndex)';
       } else {
         assert(accessorElement.isSetter);
         return 'new r.ImplicitSetterMirrorImpl('
             '${_constConstructionCode(importCollector)}, '
-            '$variableMirrorIndex, $reflectedTypeCode, $selfIndex)';
+            '$variableMirrorIndex, $reflectedTypeCode, '
+            '$dynamicReflectedTypeCode, $selfIndex)';
       }
     } else {
       // [element] is a method, a function, or an explicitly declared
       // getter or setter.
       int descriptor = _declarationDescriptor(element);
       int returnTypeIndex = _computeReturnTypeIndex(element, descriptor);
       int ownerIndex = _computeOwnerIndex(element, descriptor);
       String parameterIndicesCode = _formatAsConstList("int",
           element.parameters.map((ParameterElement parameterElement) {
         return parameters.indexOf(parameterElement);
       }));
       String reflectedReturnTypeCode = element.returnType.isVoid
           ? "null"
           : _typeCode(element.returnType, importCollector);
+      String dynamicReflectedReturnTypeCode = element.returnType.isVoid
+          ? "null"
+          : _dynamicTypeCodeOrNull(element.returnType, importCollector);
       String metadataCode = _capabilities._supportsMetadata
           ? _extractMetadataCode(
               element, _resolver, importCollector, logger, _generatedLibraryId)
           : null;
       return 'new r.MethodMirrorImpl(r"${element.name}", $descriptor, '
           '$ownerIndex, $returnTypeIndex, $reflectedReturnTypeCode, '
-          '$parameterIndicesCode, ${_constConstructionCode(importCollector)}, '
-          '$metadataCode)';
+          '$dynamicReflectedReturnTypeCode, $parameterIndicesCode, '
+          '${_constConstructionCode(importCollector)}, $metadataCode)';
     }
   }
 
   String _topLevelVariableMirrorCode(
       TopLevelVariableElement element,
       _ImportCollector importCollector,
       TransformLogger logger,
       bool reflectedTypeRequested) {
     int descriptor = _topLevelVariableDescriptor(element);
     int ownerIndex =
         _libraries.indexOf(element.enclosingElement.enclosingElement);
     int classMirrorIndex = _computeVariableTypeIndex(element, descriptor);
     String reflectedTypeCode = reflectedTypeRequested
         ? _typeCode(element.type, importCollector)
         : "null";
+    String dynamicReflectedTypeCode = reflectedTypeRequested
+        ? _dynamicTypeCodeOrNull(element.type, importCollector)
+        : "null";
     String metadataCode;
     if (_capabilities._supportsMetadata) {
       metadataCode = _extractMetadataCode(
           element, _resolver, importCollector, logger, _generatedLibraryId);
     } else {
       // We encode 'without capability' as `null` for metadata, because
       // it is a `List<Object>`, which has no other natural encoding.
       metadataCode = null;
     }
     return 'new r.VariableMirrorImpl(r"${element.name}", $descriptor, '
         '$ownerIndex, ${_constConstructionCode(importCollector)}, '
-        '$classMirrorIndex, $reflectedTypeCode, $metadataCode)';
+        '$classMirrorIndex, $reflectedTypeCode, '
+        '$dynamicReflectedTypeCode, $metadataCode)';
   }
 
   String _fieldMirrorCode(
       FieldElement element,
       _ImportCollector importCollector,
       TransformLogger logger,
       bool reflectedTypeRequested) {
     int descriptor = _fieldDescriptor(element);
     int ownerIndex = classes.indexOf(element.enclosingElement);
     int classMirrorIndex = _computeVariableTypeIndex(element, descriptor);
     String reflectedTypeCode = reflectedTypeRequested
         ? _typeCode(element.type, importCollector)
         : "null";
+    String dynamicReflectedTypeCode = reflectedTypeRequested
+        ? _dynamicTypeCodeOrNull(element.type, importCollector)
+        : "null";
     String metadataCode;
     if (_capabilities._supportsMetadata) {
       metadataCode = _extractMetadataCode(
           element, _resolver, importCollector, logger, _generatedLibraryId);
     } else {
       // We encode 'without capability' as `null` for metadata, because
       // it is a `List<Object>`, which has no other natural encoding.
       metadataCode = null;
     }
     return 'new r.VariableMirrorImpl(r"${element.name}", $descriptor, '
         '$ownerIndex, ${_constConstructionCode(importCollector)}, '
-        '$classMirrorIndex, $reflectedTypeCode, $metadataCode)';
+        '$classMirrorIndex, $reflectedTypeCode, '
+        '$dynamicReflectedTypeCode, $metadataCode)';
   }
 
   String _typeCode(DartType dartType, _ImportCollector importCollector) {
     if (dartType is TypeParameterType) {
       ClassElement owningClassElement = dartType.element.enclosingElement;
       return 'const r.FakeType(r"${_qualifiedName(owningClassElement)}.'
           '${dartType.element}")';
     }
-    return _typeCodeOfClass(dartType.element, importCollector);
+    return _typeCodeOfClass(dartType, importCollector);
   }
 
-  String _typeCodeOfClass(TypeDefiningElement typeDefiningElement,
+  /// Return a string containing code that in the generated library will
+  /// evaluate to a [Type] value like the value we would have obtained by
+  /// evaluating the [typeDefiningElement] as an expression in the library
+  /// where it occurs, but with all type arguments erased to `dynamic`.
+  /// Furthermore, return "null" for non-generic classes (that is used to
+  /// avoid duplication of identical expressions). [importCollector] is used
+  /// to find the library prefixes needed in order to obtain values from other
+  /// libraries.
+  String _dynamicTypeCodeOrNull(
+      DartType dartType, _ImportCollector importCollector) {
+    if (dartType is InterfaceType) {
+      return dartType.typeArguments.isEmpty
+          ? "null"
+          : _dynamicTypeCodeOfClass(dartType.element, importCollector);
+    }
+    // Not an interface type, let `_dynamicTypeCodeOfClass` handle it.
+    return _dynamicTypeCodeOfClass(dartType.element, importCollector);
+  }
+
+  /// Return true iff the given [type] is not and does not contain a type
+  /// variable.
+  bool _isTypeVariableFree(DartType type) {
+    if (type is TypeParameterType) return false;
+    if (type is InterfaceType) {
+      if (type.typeArguments.isEmpty) return true;
+      return type.typeArguments.every(_isTypeVariableFree);
+    }
+    // Possible kinds of types at this point (apart from several types
+    // indicating an error that we do not expect here): `BottomTypeImpl`,
+    // `DynamicTypeImpl`, `FunctionTypeImpl`, `VoidTypeImpl`. None of these
+    // have type variables.
+    return true;
+  }
+
+  /// Return a string containing a type expression that in the generated library
+  /// will serve as a type argument with the same meaning as the [classElement]
+  /// has where it occurs. The [importCollector] is used to find the library
+  /// prefixes needed in order to obtain values from other libraries.
+  String _typeCodeOfTypeArgument(
+      DartType dartType, _ImportCollector importCollector) {
+    fail() {
+      return unimplementedError(
+          "Attempt to generate code for an unsupported kind of type $dartType");
+    }
+
+    if (dartType.isDynamic) return "dynamic";
+    if (dartType is InterfaceType) {
+      ClassElement classElement = dartType.element;
+      if ((classElement is MixinApplication &&
+              classElement.declaredName == null) ||
+          classElement.isPrivate) {
+        throw fail();
+      }
+      String prefix = importCollector._getPrefix(classElement.library);
+      if (classElement.typeParameters.isEmpty) {
+        return "$prefix${classElement.name}";
+      } else {
+        if (dartType.typeArguments.every(_isTypeVariableFree)) {
+          String arguments = dartType.typeArguments
+              .map((DartType typeArgument) =>
+                  _typeCodeOfTypeArgument(typeArgument, importCollector))
+              .join(', ');
+          return "$prefix${classElement.name}<$arguments>";
+        } else {
+          throw fail();
+        }
+      }
+    } else {
+      throw fail();
+    }
+  }
+
+  /// Return a string containing code that in the generated library will
+  /// evaluate to a [Type] value like the value we would have obtained by
+  /// evaluating the [typeDefiningElement] as an expression in the library
+  /// where it occurs. [importCollector] is used to find the library prefixes
+  /// needed in order to obtain values from other libraries.
+  String _typeCodeOfClass(DartType dartType, _ImportCollector importCollector) {
+    if (dartType.isDynamic) return "dynamic";
+    if (dartType is InterfaceType) {
+      ClassElement classElement = dartType.element;
+      if ((classElement is MixinApplication &&
+              classElement.declaredName == null) ||
+          classElement.isPrivate) {
+        return 'const r.FakeType(r"${_qualifiedName(classElement)}")';
+      }
+      String prefix = importCollector._getPrefix(classElement.library);
+      if (classElement.typeParameters.isEmpty) {
+        return "$prefix${classElement.name}";
+      } else {
+        if (dartType.typeArguments.every(_isTypeVariableFree)) {
+          return "const m.TypeValue"
+              "<${_typeCodeOfTypeArgument(dartType, importCollector)}>().type";
+        } else {
+          String arguments = dartType.typeArguments
+              .map((DartType typeArgument) => typeArgument.toString())
+              .join(', ');
+          return 'const r.FakeType('
+              'r"${_qualifiedName(classElement)}<$arguments>")';
+        }
+      }
+    } else {
+      throw unimplementedError(
+          "Attempt to generate code for an unsupported kind of type $dartType");
+    }
+  }
+
+  /// Return a string containing code that in the generated library will
+  /// evaluate to a [Type] value like the value we would have obtained by
+  /// evaluating the [typeDefiningElement] as an expression in the library
+  /// where it occurs, except that all type arguments are stripped such
+  /// that we get the fully dynamic instantiation if it is a generic class.
+  /// [importCollector] is used to find the library prefixes needed in order
+  /// to obtain values from other libraries.
+  String _dynamicTypeCodeOfClass(TypeDefiningElement typeDefiningElement,
       _ImportCollector importCollector) {
-    if ((typeDefiningElement is MixinApplication &&
-            typeDefiningElement.declaredName == null) ||
-        typeDefiningElement.isPrivate) {
+    DartType type = typeDefiningElement.type;
+    if (type.isDynamic) return "dynamic";
+    if (type is InterfaceType) {
+      ClassElement classElement = type.element;
+      if ((classElement is MixinApplication &&
+              classElement.declaredName == null) ||
+          classElement.isPrivate) {
+        return 'const r.FakeType(r"${_qualifiedName(classElement)}")';
+      }
+      String prefix = importCollector._getPrefix(classElement.library);
+      return "$prefix${classElement.name}";
+    } else {
       return 'const r.FakeType(r"${_qualifiedName(typeDefiningElement)}")';
     }
-    if (typeDefiningElement.type.isDynamic) return "dynamic";
-    String prefix = importCollector._getPrefix(typeDefiningElement.library);
-    return "$prefix${typeDefiningElement.name}";
   }
 
   String _libraryMirrorCode(
       _LibraryDomain libraryDomain,
       int libraryIndex,
       Enumerator<ExecutableElement> members,
       Enumerator<TopLevelVariableElement> variables,
       int methodsOffset,
       _ImportCollector importCollector,
       TransformLogger logger) {
@@ skipping 78 matching lines @@
         classMirrorIndex = classes.contains(element.type.element)
             ? classes.indexOf(element.type.element)
             : constants.NO_CAPABILITY_INDEX;
       }
     } else {
       classMirrorIndex = constants.NO_CAPABILITY_INDEX;
     }
     String reflectedTypeCode = reflectedTypeRequested
         ? _typeCode(element.type, importCollector)
         : "null";
+    String dynamicReflectedTypeCode = reflectedTypeRequested
+        ? _dynamicTypeCodeOrNull(element.type, importCollector)
+        : "null";
     String metadataCode = "null";
     if (_capabilities._supportsMetadata) {
       FormalParameter node = element.computeNode();
       if (node == null) {
         metadataCode = "const []";
       } else {
         metadataCode = _extractMetadataCode(
             element, _resolver, importCollector, logger, _generatedLibraryId);
       }
     }
     FormalParameter parameterNode = element.computeNode();
     String defaultValueCode = "null";
     if (parameterNode is DefaultFormalParameter &&
         parameterNode.defaultValue != null) {
       defaultValueCode = _extractConstantCode(
           parameterNode.defaultValue,
           element.library,
           importCollector,
           logger,
           _generatedLibraryId,
           _resolver);
     }
     return 'new r.ParameterMirrorImpl(r"${element.name}", $descriptor, '
         '$ownerIndex, ${_constConstructionCode(importCollector)}, '
-        '$classMirrorIndex, $reflectedTypeCode, $metadataCode, '
-        '$defaultValueCode)';
+        '$classMirrorIndex, $reflectedTypeCode, $dynamicReflectedTypeCode, '
+        '$metadataCode, $defaultValueCode)';
   }
 }
 
 /// Auxiliary class used by `classes`. Its `expand` method expands
 /// its argument to a fixed point, based on the `successors` method.
 class _SubtypesFixedPoint extends FixedPoint<ClassElement> {
   final Map<ClassElement, Set<ClassElement>> subtypes;
 
   _SubtypesFixedPoint(this.subtypes);
 
@@ skipping 803 matching lines @@
         capability is ec.LibraryCapability);
   }
 }
 
 /// Collects the libraries that needs to be imported, and gives each library
 /// a unique prefix.
 class _ImportCollector {
   Map<LibraryElement, String> _mapping = <LibraryElement, String>{};
   int _count = 0;
 
-  /// Returns the prefix associated with [library].
+  /// Returns the prefix associated with [library]. Iff it is non-empty
+  /// it includes the period.
   String _getPrefix(LibraryElement library) {
     if (library.isDartCore) return "";
     String prefix = _mapping[library];
     if (prefix != null) return prefix;
     prefix = "prefix$_count.";
     _count++;
     _mapping[library] = prefix;
     return prefix;
   }
 
@@ skipping 1874 matching lines @@
   return functionElement == null
       ? "null"
       : "${functionElement.library.name}.${functionElement.name}";
 }
 
 String _qualifiedTypeParameterName(TypeParameterElement typeParameterElement) {
   if (typeParameterElement == null) return "null";
   return "${_qualifiedName(typeParameterElement.enclosingElement)}."
       "${typeParameterElement.name}";
 }