Implements support for reflection on parameters.

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:io';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:path/path.dart' as path;
 import 'element_capability.dart' as ec;
 import 'encoding_constants.dart' as constants;
 import "reflectable_class_constants.dart" as reflectable_class_constants;
 import 'transformer_errors.dart' as errors;
 
 class ReflectionWorld {
   final List<_ReflectorDomain> reflectors = new List<_ReflectorDomain>();
@@ skipping 24 matching lines @@
     }));
   }
 }
 
 /// Similar to a `Set<T>` but also keeps track of the index of the first
 /// insertion of each item.
 class Enumerator<T> {
   final Map<T, int> _map = new Map<T, int>();
   int _count = 0;
 
+  bool _contains(T t) => _map.containsKey(t);
+
   get length => _count;
 
   /// Tries to insert [t]. If it was already there return false, else insert it
   /// and return true.
   bool add(T t) {
-    if (_map.containsKey(t)) return false;
+    if (_contains(t)) return false;
     _map[t] = _count;
     ++_count;
     return true;
   }
 
   /// Returns the index of a given item.
   int indexOf(T t) {
     return _map[t];
   }
 
@@ skipping 43 matching lines @@
 
     List<String> parameterNames = type.parameters
         .map((ParameterElement parameter) => parameter.name)
         .toList();
 
     List<String> NamedParameterNames = type.namedParameterTypes.keys.toList();
 
     String positionals = new Iterable.generate(
         requiredPositionalCount, (int i) => parameterNames[i]).join(", ");
 
-    String optionalsWithDefaults = new Iterable.generate(
-        optionalPositionalCount, (int i) {
+    String optionalsWithDefaults =
+        new Iterable.generate(optionalPositionalCount, (int i) {
       String defaultValueCode =
           constructor.parameters[requiredPositionalCount + i].defaultValueCode;
       String defaultValueString =
           defaultValueCode == null ? "" : " = $defaultValueCode";
       return "${parameterNames[i + requiredPositionalCount]}"
           "$defaultValueString";
     }).join(", ");
 
-    String namedWithDefaults = new Iterable.generate(NamedParameterNames.length,
-        (int i) {
+    String namedWithDefaults =
+        new Iterable.generate(NamedParameterNames.length, (int i) {
       // TODO(#8) future: Recreate default values.
       // TODO(#8) implement: Until that is done, recognize
       // unhandled cases, and emit error/warning.
       String defaultValueCode =
           constructor.parameters[requiredPositionalCount + i].defaultValueCode;
       String defaultValueString =
           defaultValueCode == null ? "" : ": $defaultValueCode";
       return "${NamedParameterNames[i]}$defaultValueString";
     }).join(", ");
 
@@ skipping 28 matching lines @@
   String _constConstructionCode(_ImportCollector importCollector) {
     String prefix = importCollector._getPrefix(_reflector.library);
     return "const $prefix.${_reflector.name}()";
   }
 
   String _generateCode(Resolver resolver, _ImportCollector importCollector,
       TransformLogger logger, AssetId dataId) {
     Enumerator<ClassElement> classes = new Enumerator<ClassElement>();
     Enumerator<ExecutableElement> members = new Enumerator<ExecutableElement>();
     Enumerator<FieldElement> fields = new Enumerator<FieldElement>();
+    Enumerator<ParameterElement> parameters =
+        new Enumerator<ParameterElement>();
     Set<String> instanceGetterNames = new Set<String>();
     Set<String> instanceSetterNames = new Set<String>();
 
-    // Fill in [classes], [members], [fields], [instanceGetterNames],
-    // and [instanceSetterNames].
+    // Fill in [classes], [members], [fields], [parameters],
+    // [instanceGetterNames], and [instanceSetterNames].
     for (_ClassDomain classDomain in _annotatedClasses) {
       // Gather all annotated classes.
       classes.add(classDomain._classElement);
 
       // Gather the behavioral interface into [members]. Note that
       // this includes implicitly generated getters and setters, but
       // omits fields. Also note that this does not match the
       // semantics of the `declarations` method in a [ClassMirror].
       classDomain._declarations.forEach(members.add);
 
       // Add the behavioral interface from this class (redundantly) and
       // all superclasses (which matters) to [members], such that it
       // contains both the behavioral parts for the target class and its
       // superclasses, and the program structure oriented parts for the
       // target class (omitting those from its superclasses).
       classDomain._instanceMembers.forEach(members.add);
 
+      // Add all the formal parameters (as a single, global set) which
+      // are declared by any of the methods in `classDomain._declarations`.
+      classDomain._declaredParameters.forEach(parameters.add);
+
       // Gather the fields declared in the target class (not inherited
       // ones) in [fields], i.e., the elements missing from [members]
       // at this point, in order to support `declarations` in a
       // [ClassMirror].
       classDomain._declaredFields.forEach(fields.add);
 
       // Gather all getters and setters based on [instanceMembers], including
       // both explicitly declared ones, implicitly generated ones for fields,
       // and the implicitly generated ones that correspond to method tear-offs.
       classDomain._instanceMembers.forEach((ExecutableElement instanceMember) {
@@ skipping 52 matching lines @@
       String name = setterName.substring(0, setterName.length - 1);
       String className = classElement.name;
       String prefix = importCollector._getPrefix(classElement.library);
       return 'r"$setterName": (value) => $prefix.$className.$name = value';
     }
 
     // Compute `includedClasses`, i.e., the set of classes which are
     // annotated, or the upwards-closed completion of that set.
     Set<_ClassDomain> includedClasses = new Set<_ClassDomain>();
     includedClasses.addAll(_annotatedClasses);
+    if (_capabilities._impliesParameterTypes) {
+      parameters.items.forEach((ParameterElement parameterElement) {
+        Element parameterType = parameterElement.type.element;
+        if (parameterType is ClassElement) {
+          includedClasses.add(_createClassDomain(parameterType, this));
+          classes.add(parameterType);
+        }
+      });
+    }
     if (_capabilities._impliesUpwardsClosure) {
       Set<_ClassDomain> workingSetOfClasses = includedClasses;
       while (true) {
         // Invariant for `workingSetOfClasses`: Every class from
         // `includedClasses` for which it is possible that its superclass
         // is not yet in `includedClasses` must be a member of
         // `workingSetOfClasses`.
         Set<_ClassDomain> additionalClasses = new Set<_ClassDomain>();
         workingSetOfClasses.forEach((_ClassDomain workingClass) {
           InterfaceType workingSuperType = workingClass._classElement.supertype;
@@ skipping 12 matching lines @@
         includedClasses.addAll(additionalClasses);
         additionalClasses.forEach((_ClassDomain classDomain) {
           classes.add(classDomain._classElement);
         });
         workingSetOfClasses = additionalClasses;
       }
     }
 
     // Generate the class mirrors.
     int classIndex = 0;
-    String classMirrorsCode = _formatAsList(includedClasses
-        .map((_ClassDomain classDomain) {
-
+    String classMirrorsCode =
+        _formatAsList(includedClasses.map((_ClassDomain classDomain) {
       // Fields go first in [memberMirrors], so they will get the
       // same index as in [fields].
-      Iterable<int> fieldsIndices = classDomain._declaredFields
-          .map((FieldElement element) {
+      Iterable<int> fieldsIndices =
+          classDomain._declaredFields.map((FieldElement element) {
         return fields.indexOf(element);
       });
 
       int fieldsLength = fields.length;
 
       // All the elements in the behavioral interface go after the
       // fields in [memberMirrors], so they must get an offset of
       // `fields.length` on the index.
       Iterable<int> methodsIndices = classDomain._declarations
           .where(_executableIsntImplicitGetterOrSetter)
           .map((ExecutableElement element) {
         // TODO(eernst) implement: The "magic" default constructor in `Object`
         // (the one that ultimately allocates the memory for _every_ new object)
         // has no index, which creates the need to catch a `null` here.
         // Search for "magic" to find other occurrences of the same issue.
         // For now, we provide the index -1 for this declaration, because
         // it is not yet supported. Need to find the correct solution, though!
         int index = members.indexOf(element);
         return index == null ? -1 : index + fieldsLength;
       });
 
       List<int> declarationsIndices = <int>[]
         ..addAll(fieldsIndices)
         ..addAll(methodsIndices);
       String declarationsCode = _formatAsList(declarationsIndices);
 
       // All instance members belong to the behavioral interface, so they
       // also get an offset of `fields.length`.
-      String instanceMembersCode = _formatAsList(classDomain._instanceMembers
-          .map((ExecutableElement element) {
+      String instanceMembersCode = _formatAsList(
+          classDomain._instanceMembers.map((ExecutableElement element) {
         // TODO(eernst) implement: The "magic" default constructor has
         // index: -1; adjust this when support for it has been implemented.
         int index = members.indexOf(element);
         return index == null ? -1 : index + fieldsLength;
       }));
 
       InterfaceType superType = classDomain._classElement.supertype;
       ClassElement superclass = superType == null ? null : superType.element;
       String superclassIndex;
       if (superclass == null) {
         superclassIndex = null;
       } else {
         int index = classes.indexOf(superclass);
         if (index == null) {
           // There is a superclass, but we have no capability for it.
           index = -1;
         }
         superclassIndex = "$index";
       }
 
       String constructorsCode;
 
       if (classDomain._classElement.isAbstract) {
         constructorsCode = '{}';
       } else {
-        constructorsCode = _formatAsMap(classDomain._constructors
-            .map((ConstructorElement constructor) {
+        constructorsCode = _formatAsMap(
+            classDomain._constructors.map((ConstructorElement constructor) {
           String code = _constructorCode(constructor, importCollector);
           return 'r"${constructor.name}": $code';
         }));
       }
 
       String classMetadataCode;
       if (_capabilities._supportsMetadata) {
         classMetadataCode = _extractMetadataCode(classDomain._classElement,
             resolver, importCollector, logger, dataId);
       } else {
         classMetadataCode = "null";
       }
 
       String staticGettersCode = _formatAsMap([
         classDomain._declaredMethods
             .where((ExecutableElement element) => element.isStatic),
         classDomain._declaredAndImplicitAccessors.where(
             (PropertyAccessorElement element) =>
                 element.isStatic && element.isGetter)
       ].expand((x) => x).map((ExecutableElement element) =>
           staticGettingClosure(classDomain._classElement, element.name)));
-      String staticSettersCode = _formatAsMap(
-          classDomain._declaredAndImplicitAccessors
-              .where((PropertyAccessorElement element) =>
-                  element.isStatic && element.isSetter)
-              .map((PropertyAccessorElement element) => _staticSettingClosure(
-                  classDomain._classElement, element.name)));
+      String staticSettersCode = _formatAsMap(classDomain
+          ._declaredAndImplicitAccessors
+          .where((PropertyAccessorElement element) =>
+              element.isStatic && element.isSetter)
+          .map((PropertyAccessorElement element) =>
+              _staticSettingClosure(classDomain._classElement, element.name)));
       String result = 'new r.ClassMirrorImpl(r"${classDomain._simpleName}", '
           'r"${classDomain._qualifiedName}", $classIndex, '
           '${_constConstructionCode(importCollector)}, '
           '$declarationsCode, $instanceMembersCode, $superclassIndex, '
           '$staticGettersCode, $staticSettersCode, $constructorsCode, '
           '$classMetadataCode)';
       classIndex++;
       return result;
     }));
 
     String gettersCode = _formatAsMap(instanceGetterNames.map(gettingClosure));
     String settersCode = _formatAsMap(instanceSetterNames.map(settingClosure));
 
-    Iterable<String> methodsList = members.items
-        .map((ExecutableElement element) {
+    Iterable<String> methodsList =
+        members.items.map((ExecutableElement element) {
       int descriptor = _declarationDescriptor(element);
       int ownerIndex = classes.indexOf(element.enclosingElement);
+      List<int> parameterIndices =
+          element.parameters.map((ParameterElement parameterElement) {
+        return parameters.indexOf(parameterElement);
+      });
+      String parameterIndicesCode = _formatAsList(parameterIndices);
       String metadataCode;
       if (_capabilities._supportsMetadata) {
         metadataCode = _extractMetadataCode(
             element, resolver, importCollector, logger, dataId);
       } else {
         metadataCode = null;
       }
       return 'new r.MethodMirrorImpl(r"${element.name}", $descriptor, '
-          '$ownerIndex, ${_constConstructionCode(importCollector)}, '
-          '$metadataCode)';
+          '$ownerIndex, $parameterIndicesCode, '
+          '${_constConstructionCode(importCollector)}, $metadataCode)';
     });
 
     Iterable<String> fieldsList = fields.items.map((FieldElement element) {
       int descriptor = _fieldDescriptor(element);
       int ownerIndex = classes.indexOf(element.enclosingElement);
       String metadataCode;
       if (_capabilities._supportsMetadata) {
         metadataCode = _extractMetadataCode(
             element, resolver, importCollector, logger, dataId);
       } else {
         metadataCode = null;
       }
       return 'new r.VariableMirrorImpl("${element.name}", $descriptor, '
           '$ownerIndex, ${_constConstructionCode(importCollector)}, '
           '$metadataCode)';
     });
 
     List<String> membersList = <String>[]
       ..addAll(fieldsList)
       ..addAll(methodsList);
     String membersCode = _formatAsList(membersList);
 
-    String typesCode = _formatAsList(classes.items
-        .map((ClassElement classElement) {
+    String typesCode =
+        _formatAsList(classes.items.map((ClassElement classElement) {
       String prefix = importCollector._getPrefix(classElement.library);
       return "$prefix.${classElement.name}";
     }));
 
-    return "new r.ReflectorData($classMirrorsCode, $membersCode, $typesCode, "
-        "$gettersCode, $settersCode)";
+    Iterable<String> parametersList =
+        parameters.items.map((ParameterElement element) {
+      int descriptor = _parameterDescriptor(element);
+      int ownerIndex = members.indexOf(element.enclosingElement);
+      int classMirrorIndex = classes._contains(element.type.element)
+          ? classes.indexOf(element.type.element)
+          : -1;
+      String metadataCode;
+      metadataCode = _capabilities._supportsMetadata ? "<Object>[]" : "null";
+      // TODO(eernst) implement: Detect and, if possible, handle the case
+      // where it is incorrect to move element.defaultValueCode out of its
+      // original scope. If we cannot solve the problem we should issue
+      // a warning (it's worse than `new UndefinedClass()`, because it
+      // might "work" with a different semantics at runtime, rather than just
+      // failing if ever executed).
+      return 'new r.ParameterMirrorImpl(r"${element.name}", $descriptor, '
+          '$ownerIndex, ${_constConstructionCode(importCollector)}, '
+          '$metadataCode, ${element.defaultValueCode}, $classMirrorIndex)';
+    });
+    String parameterMirrorsCode = _formatAsList(parametersList);
+
+    return "new r.ReflectorData($classMirrorsCode, $membersCode, "
+        "$parameterMirrorsCode, $typesCode, $gettersCode, $settersCode)";
   }
 }
 
 /// Information about reflectability for a given class.
 class _ClassDomain {
   /// Element describing the target class.
   final ClassElement _classElement;
 
   /// Fields declared by [classElement] and included for reflection support,
   /// according to the reflector described by the [reflectorDomain];
   /// obtained by filtering `classElement.fields`.
   final Iterable<FieldElement> _declaredFields;
 
   /// Methods which are declared by [classElement] and included for
   /// reflection support, according to the reflector described by
   /// [reflectorDomain]; obtained by filtering `classElement.methods`.
   final Iterable<MethodElement> _declaredMethods;
 
+  /// Formal parameters declared by one of the [_declaredMethods].
+  final Iterable<ParameterElement> _declaredParameters;
+
   /// Getters and setters possessed by [classElement] and included for
   /// reflection support, according to the reflector described by
   /// [reflectorDomain]; obtained by filtering `classElement.accessors`.
   /// Note that it includes declared as well as synthetic accessors,
   /// implicitly created as getters/setters for fields.
   final Iterable<PropertyAccessorElement> _declaredAndImplicitAccessors;
 
   /// Constructors declared by [classElement] and included for reflection
   /// support, according to the reflector described by [reflectorDomain];
   /// obtained by filtering `classElement.constructors`.
   final Iterable<ConstructorElement> _constructors;
 
   /// The reflector domain that holds [this] object as one of its
   /// class domains.
   final _ReflectorDomain _reflectorDomain;
 
-  _ClassDomain(this._classElement, this._declaredFields, this._declaredMethods,
-      this._declaredAndImplicitAccessors, this._constructors,
+  _ClassDomain(
+      this._classElement,
+      this._declaredFields,
+      this._declaredMethods,
+      this._declaredParameters,
+      this._declaredAndImplicitAccessors,
+      this._constructors,
       this._reflectorDomain);
 
   String get _simpleName => _classElement.name;
   String get _qualifiedName {
     return "${_classElement.library.name}.${_classElement.name}";
   }
 
   /// Returns the declared methods, accessors and constructors in
   /// [classElement]. Note that this includes synthetic getters and
   /// setters, and omits fields; in other words, it provides the
   /// behavioral point of view on the class. Also note that this is not
   /// the same semantics as that of `declarations` in [ClassMirror].
   Iterable<ExecutableElement> get _declarations {
     // TODO(sigurdm) feature: Include type variables (if we keep them).
-    return [
-      _declaredMethods,
-      _declaredAndImplicitAccessors,
-      _constructors
-    ].expand((x) => x);
+    return [_declaredMethods, _declaredAndImplicitAccessors, _constructors]
+        .expand((x) => x);
   }
 
   /// Finds all instance members by going through the class hierarchy.
   Iterable<ExecutableElement> get _instanceMembers {
     Map<String, ExecutableElement> helper(ClassElement classElement) {
       if (_reflectorDomain._instanceMemberCache[classElement] != null) {
         return _reflectorDomain._instanceMemberCache[classElement];
       }
       Map<String, ExecutableElement> result =
           new Map<String, ExecutableElement>();
 
       void addIfCapable(ExecutableElement member) {
+        if (member.isPrivate) return;
         // If [member] is a synthetic accessor created from a field, search for
         // the metadata on the original field.
         List<ElementAnnotation> metadata = (member is PropertyAccessorElement &&
             member.isSynthetic) ? member.variable.metadata : member.metadata;
-        if (_reflectorDomain._capabilities.supportsInstanceInvoke(
-            member.name, metadata)) {
+        if (_reflectorDomain._capabilities
+            .supportsInstanceInvoke(member.name, metadata)) {
           result[member.name] = member;
         }
       }
       if (classElement.supertype != null) {
         helper(classElement.supertype.element)
             .forEach((String name, ExecutableElement member) {
           addIfCapable(member);
         });
       }
       for (InterfaceType mixin in classElement.mixins) {
@@ skipping 194 matching lines @@
   }
 
   // Returns [true] iff these [Capabilities] specify reflection support where
   // the set of included classes must be upwards closed, i.e., extra classes
   // must be added beyond the ones that are directly included as reflectable
   // because we must support operations like `superclass`.
   bool get _impliesUpwardsClosure {
     return _capabilities.any((ec.ReflectCapability capability) =>
         capability == ec.typeRelationsCapability);
   }
+
+  bool get _impliesParameterTypes {
+    bool haveDeclarations =
+        _capabilities.any((ec.ReflectCapability capability) {
+      return capability == ec.declarationsCapability;
+    });
+    if (!haveDeclarations) return false;
+    return _capabilities.any((ec.ReflectCapability capability) {
+      return capability is ec.TypeCapability ||
+          capability is ec.TypingCapability;
+    });
+  }
 }
 
 /// Collects the libraries that needs to be imported, and gives each library
 /// a unique prefix.
 class _ImportCollector {
   Map<LibraryElement, String> _mapping = new Map<LibraryElement, String>();
   int _count = 0;
 
   /// Returns the prefix associated with [library].
   String _getPrefix(LibraryElement library) {
@@ skipping 225 matching lines @@
               }
               ClassElement reflector =
                   value.fields["(super)"].fields["reflector"].type.element;
               if (reflector == null ||
                   reflector.type.element.supertype.element !=
                       reflectableClass) {
                 String found =
                     reflector == null ? "" : " Found ${reflector.name}";
                 _warn(
                     "The reflector must be a direct subclass of Reflectable." +
-                        found, import);
+                        found,
+                    import);
                 continue;
               }
               globalPatterns
                   .putIfAbsent(
                       new RegExp(pattern), () => new List<ClassElement>())
                   .add(reflector);
             }
           } else if (metadatum.element ==
               globalQuantifyMetaCapabilityConstructor) {
             EvaluationResultImpl evaluation = metadatum.evaluationResult;
             if (evaluation != null && evaluation.value != null) {
               DartObjectImpl value = evaluation.value;
               Object metadataFieldValue = value.fields["metadataType"].value;
               if (metadataFieldValue == null ||
                   value.fields["metadataType"].type.element != typeClass) {
                 // TODO(sigurdm) implement: Create a span for the annotation.
-                _warn("The metadata must be a Type. "
+                _warn(
+                    "The metadata must be a Type. "
                     "Found ${value.fields["metadataType"].type.element.name}",
                     import);
                 continue;
               }
               ClassElement reflector =
                   value.fields["(super)"].fields["reflector"].type.element;
               if (reflector == null ||
                   reflector.type.element.supertype.element !=
                       reflectableClass) {
                 String found =
                     reflector == null ? "" : " Found ${reflector.name}";
                 _warn(
                     "The reflector must be a direct subclass of Reflectable." +
-                        found, import);
+                        found,
+                    import);
                 continue;
               }
               globalMetadata
                   .putIfAbsent(
                       metadataFieldValue, () => new List<ClassElement>())
                   .add(reflector);
             }
           }
         }
       }
@@ skipping 60 matching lines @@
             // Add the class if it is annotated by a reflector.
             ClassElement reflector =
                 _getReflectableAnnotation(metadatum, focusClass);
             if (reflector != null) {
               addClassDomain(type, reflector);
             }
           }
           // Add the class to the domain of all reflectors associated with a
           // pattern, via GlobalQuantifyCapability, that matches the qualified
           // name of the class.
-          globalPatterns
-              .forEach((RegExp pattern, List<ClassElement> reflectors) {
+          globalPatterns.forEach(
+              (RegExp pattern, List<ClassElement> reflectors) {
             String qualifiedName = "${type.library.name}.${type.name}";
             if (pattern.hasMatch(qualifiedName)) {
               for (ClassElement reflector in reflectors) {
                 addClassDomain(type, reflector);
               }
             }
           });
         }
       }
     }
@@ skipping 10 matching lines @@
   void _collectMissingImports(_ReflectorDomain domain) {
     LibraryElement metadataLibrary = domain._reflector.library;
     for (_ClassDomain classData in domain._annotatedClasses) {
       LibraryElement annotatedLibrary = classData._classElement.library;
       if (metadataLibrary != annotatedLibrary) {
         domain._missingImports.add(annotatedLibrary);
       }
     }
   }
 
-  ImportElement _findLastImport(LibraryElement library) {
-    if (library.imports.isNotEmpty) {
-      ImportElement importElement = library.imports.lastWhere(
-          (importElement) => importElement.node != null, orElse: () => null);
-      if (importElement != null) {
-        // Found an import element with a node (i.e., a non-synthetic one).
-        return importElement;
-      } else {
-        // No non-synthetic imports.
-        return null;
-      }
-    }
-    // library.imports.isEmpty
-    return null;
-  }
-
-  ExportElement _findFirstExport(LibraryElement library) {
-    if (library.exports.isNotEmpty) {
-      ExportElement exportElement = library.exports.firstWhere(
-          (exportElement) => exportElement.node != null, orElse: () => null);
-      if (exportElement != null) {
-        // Found an export element with a node (i.e., a non-synthetic one)
-        return exportElement;
-      } else {
-        // No non-synthetic exports.
-        return null;
-      }
-    }
-    // library.exports.isEmpty
-    return null;
-  }
-
-  /// Find a suitable index for insertion of additional import directives
-  /// into [targetLibrary].
-  int _newImportIndex(LibraryElement targetLibrary) {
-    // Index in [source] where the new import directive is inserted, we
-    // use 0 as the default placement (at the front of the file), but
-    // make a heroic attempt to find a better placement first.
-    int index = 0;
-    ImportElement importElement = _findLastImport(targetLibrary);
-    if (importElement != null) {
-      index = importElement.node.end;
-    } else {
-      // No non-synthetic import directives present.
-      ExportElement exportElement = _findFirstExport(targetLibrary);
-      if (exportElement != null) {
-        // Put the new import before the exports
-        index = exportElement.node.offset;
-      } else {
-        // No non-synthetic import nor export directives present.
-        CompilationUnit compilationUnitNode =
-            targetLibrary.definingCompilationUnit.node;
-        LibraryDirective libraryDirective = compilationUnitNode.directives
-            .firstWhere((directive) => directive is LibraryDirective,
-                orElse: () => null);
-        if (libraryDirective != null) {
-          // Put the new import after the library name directive.
-          index = libraryDirective.end;
-        } else {
-          // No library directive either, keep index == 0.
-        }
-      }
-    }
-    return index;
-  }
-
   /// Returns the [ReflectCapability] denoted by the given [initializer].
   ec.ReflectCapability _capabilityOfExpression(LibraryElement capabilityLibrary,
       Expression expression, LibraryElement containingLibrary) {
     EvaluationResult evaluated =
         _resolver.evaluateConstant(containingLibrary, expression);
 
     if (!evaluated.isValid) {
       _logger.error("Invalid constant $expression in capability-list.");
     }
 
     DartObjectImpl constant = evaluated.value;
 
     ParameterizedType dartType = constant.type;
     // We insist that the type must be a class, and we insist that it must
     // be in the given `capabilityLibrary` (because we could never know
     // how to interpret the meaning of a user-written capability class, so
     // users cannot write their own capability classes).
     if (dartType.element is! ClassElement) {
       if (dartType.element.source != null) {
-        _logger.error(errors.applyTemplate(errors.SUPER_ARGUMENT_NON_CLASS, {
-          "type": dartType.displayName
-        }), span: _resolver.getSourceSpan(dartType.element));
+        _logger.error(
+            errors.applyTemplate(errors.SUPER_ARGUMENT_NON_CLASS,
+                {"type": dartType.displayName}),
+            span: _resolver.getSourceSpan(dartType.element));
       } else {
         _logger.error(errors.applyTemplate(
             errors.SUPER_ARGUMENT_NON_CLASS, {"type": dartType.displayName}));
       }
     }
     ClassElement classElement = dartType.element;
     if (classElement.library != capabilityLibrary) {
-      _logger.error(errors.applyTemplate(errors.SUPER_ARGUMENT_WRONG_LIBRARY, {
-        "library": capabilityLibrary,
-        "element": classElement
-      }), span: _resolver.getSourceSpan(classElement));
+      _logger.error(
+          errors.applyTemplate(errors.SUPER_ARGUMENT_WRONG_LIBRARY,
+              {"library": capabilityLibrary, "element": classElement}),
+          span: _resolver.getSourceSpan(classElement));
     }
 
     /// Extracts the namePattern String from an instance of a subclass of
     /// NamePatternCapability.
     String extractNamePattern(DartObjectImpl constant) {
       if (constant.fields == null ||
           constant.fields["(super)"] == null ||
           constant.fields["(super)"].fields["namePattern"] == null ||
           constant.fields["(super)"].fields["namePattern"].stringValue ==
               null) {
@@ skipping 148 matching lines @@
     List<String> imports = new List<String>();
     world.importCollector._libraries.forEach((LibraryElement library) {
       Uri uri = _resolver.getImportUri(library, from: generatedId);
       String prefix = world.importCollector._getPrefix(library);
       imports.add("import '$uri' as $prefix;");
     });
     imports.sort();
 
     String args =
         (entryPointLibrary.entryPoint.parameters.length == 0) ? "" : "args";
-    StringBuffer buffer = new StringBuffer();
     return """
 // This file has been generated by the reflectable package.
 // https://github.com/dart-lang/reflectable.
 
 library reflectable_generated_main_library;
 
 import "dart:core";
 import "$originalEntryPointFilename" as original show main;
 ${imports.join('\n')}
 
@@ skipping 100 matching lines @@
 /// which case we can drop this class and use that method.
 class _AggregateTransformWrapper implements Transform {
   final AggregateTransform _aggregateTransform;
   final Asset primaryInput;
   _AggregateTransformWrapper(this._aggregateTransform, this.primaryInput);
   TransformLogger get logger => _aggregateTransform.logger;
   Future<Asset> getInput(AssetId id) => _aggregateTransform.getInput(id);
   Future<String> readInputAsString(AssetId id, {Encoding encoding}) {
     return _aggregateTransform.readInputAsString(id, encoding: encoding);
   }
+
   Stream<List<int>> readInput(AssetId id) => _aggregateTransform.readInput(id);
   Future<bool> hasInput(AssetId id) => _aggregateTransform.hasInput(id);
   void addOutput(Asset output) => _aggregateTransform.addOutput(output);
   void consumePrimary() => _aggregateTransform.consumePrimary(primaryInput.id);
 }
 
 bool _accessorIsntImplicitGetterOrSetter(PropertyAccessorElement accessor) {
   return !accessor.isSynthetic || (!accessor.isGetter && !accessor.isSetter);
 }
 
 bool _executableIsntImplicitGetterOrSetter(ExecutableElement executable) {
   return executable is! PropertyAccessorElement ||
       _accessorIsntImplicitGetterOrSetter(executable);
 }
 
 /// Returns an integer encoding of the kind and attributes of the given
 /// field.
 int _fieldDescriptor(FieldElement element) {
   int result = constants.field;
   if (element.isPrivate) result |= constants.privateAttribute;
   if (element.isSynthetic) result |= constants.syntheticAttribute;
   if (element.isConst) result |= constants.constAttribute;
   if (element.isFinal) result |= constants.finalAttribute;
   if (element.isStatic) result |= constants.staticAttribute;
   return result;
 }
 
 /// Returns an integer encoding of the kind and attributes of the given
+/// parameter.
+int _parameterDescriptor(ParameterElement element) {
+  int result = constants.parameter;
+  if (element.isPrivate) result |= constants.privateAttribute;
+  if (element.isSynthetic) result |= constants.syntheticAttribute;
+  if (element.isConst) result |= constants.constAttribute;
+  if (element.isFinal) result |= constants.finalAttribute;
+  if (element.defaultValueCode != null) {
+    result |= constants.hasDefaultValueAttribute;
+  }
+  if (element.parameterKind.isOptional) {
+    result |= constants.optionalAttribute;
+  }
+  if (element.parameterKind == ParameterKind.NAMED) {
+    result |= constants.namedAttribute;
+  }
+  if (element.type.isDynamic) {
+    result |= constants.dynamicAttribute;
+  }
+  Element elementType = element.type.element;
+  if (elementType is ClassElement) {
+    result |= constants.classTypeAttribute;
+  }
+  return result;
+}
+
+/// Returns an integer encoding of the kind and attributes of the given
 /// method/constructor/getter/setter.
 int _declarationDescriptor(ExecutableElement element) {
   int result;
   if (element is PropertyAccessorElement) {
     result = element.isGetter ? constants.getter : constants.setter;
   } else if (element is ConstructorElement) {
     if (element.isFactory) {
       result = constants.factoryConstructor;
     } else {
       result = constants.generativeConstructor;
@@ skipping 19 matching lines @@
         : "${element.enclosingElement.name}.${element.name}";
   }
   return element.name;
 }
 
 String _formatAsList(Iterable parts) => "[${parts.join(", ")}]";
 
 String _formatAsMap(Iterable parts) => "{${parts.join(", ")}}";
 
 /// Returns code that will reproduce the given constant expression.
-String _extractConstantCode(Expression expression,
-    LibraryElement originatingLibrary, Resolver resolver,
+String _extractConstantCode(
+    Expression expression,
+    LibraryElement originatingLibrary,
+    Resolver resolver,
     _ImportCollector importCollector) {
   if (expression is ListLiteral) {
     List<String> elements = expression.elements.map((Expression subExpression) {
       return _extractConstantCode(
           subExpression, originatingLibrary, resolver, importCollector);
     });
     // TODO(sigurdm) feature: Type arguments.
     return "const ${_formatAsList(elements)}";
   } else if (expression is MapLiteral) {
     List<String> elements = expression.entries.map((MapLiteralEntry entry) {
       String key = _extractConstantCode(
           entry.key, originatingLibrary, resolver, importCollector);
       String value = _extractConstantCode(
           entry.value, originatingLibrary, resolver, importCollector);
       return "$key: $value";
     });
     // TODO(sigurdm) feature: Type arguments.
     return "const ${_formatAsMap(elements)}";
   } else if (expression is InstanceCreationExpression) {
     String constructor = expression.constructorName.toSource();
     LibraryElement libraryOfConstructor = expression.staticElement.library;
     importCollector._addLibrary(libraryOfConstructor);
     String prefix =
         importCollector._getPrefix(expression.staticElement.library);
     // TODO(sigurdm) implement: Named arguments.
-    String arguments = expression.argumentList.arguments
-        .map((Expression argument) {
+    String arguments =
+        expression.argumentList.arguments.map((Expression argument) {
       return _extractConstantCode(
           argument, originatingLibrary, resolver, importCollector);
     }).join(", ");
     // TODO(sigurdm) feature: Type arguments.
     return "const $prefix.$constructor($arguments)";
   } else if (expression is Identifier) {
     Element element = expression.staticElement;
     importCollector._addLibrary(element.library);
     String prefix = importCollector._getPrefix(element.library);
     Element enclosingElement = element.enclosingElement;
@@ skipping 123 matching lines @@
           span: resolver.getSourceSpan(element));
       continue;
     }
     importCollector._addLibrary(library);
     String prefix = importCollector._getPrefix(library);
     if (annotationNode.arguments != null) {
       // A const constructor.
       String constructor = (annotationNode.constructorName == null)
           ? annotationNode.name
           : "${annotationNode.name}.${annotationNode.constructorName}";
-      String arguments = annotationNode.arguments.arguments
-          .map((Expression argument) {
+      String arguments =
+          annotationNode.arguments.arguments.map((Expression argument) {
         return _extractConstantCode(
             argument, element.library, resolver, importCollector);
       }).join(", ");
       metadataParts.add("const $prefix.$constructor($arguments)");
     } else {
       // A field reference.
       metadataParts.add("$prefix.${annotationNode.name}");
     }
   }
 
   return _formatAsList(metadataParts);
 }
 
-Iterable<FieldElement> _declaredFields(
+Iterable<FieldElement> _extractDeclaredFields(
     ClassElement classElement, _Capabilities capabilities) {
   return classElement.fields.where((FieldElement field) {
+    if (field.isPrivate) return false;
     Function capabilityChecker = field.isStatic
         ? capabilities.supportsStaticInvoke
         : capabilities.supportsInstanceInvoke;
     return !field.isSynthetic && capabilityChecker(field.name, field.metadata);
   });
 }
 
-Iterable<MethodElement> _declaredMethods(
+Iterable<MethodElement> _extractDeclaredMethods(
     ClassElement classElement, _Capabilities capabilities) {
   return classElement.methods.where((MethodElement method) {
+    if (method.isPrivate) return false;
     Function capabilityChecker = method.isStatic
         ? capabilities.supportsStaticInvoke
         : capabilities.supportsInstanceInvoke;
     return capabilityChecker(method.name, method.metadata);
   });
 }
 
+Iterable<ParameterElement> _extractDeclaredParameters(
+    Iterable<MethodElement> declaredMethods) {
+  List<ParameterElement> result = <ParameterElement>[];
+  for (MethodElement declaredMethod in declaredMethods) {
+    result.addAll(declaredMethod.parameters);
+  }
+  return result;
+}
+
 /// Returns the [PropertyAccessorElement]s which are the accessors
 /// of the given [classElement], including both the declared ones
 /// and the implicitly generated ones corresponding to fields. This
 /// is the set of accessors that corresponds to the behavioral interface
 /// of the corresponding instances, as opposed to the source code oriented
 /// interface, e.g., `declarations`. But the latter can be computed from
 /// here, by filtering out the accessors whose `isSynthetic` is true
 /// and adding the fields.
 Iterable<PropertyAccessorElement> _declaredAndImplicitAccessors(
     ClassElement classElement, _Capabilities capabilities) {
   return classElement.accessors.where((PropertyAccessorElement accessor) {
+    if (accessor.isPrivate) return false;
     Function capabilityChecker = accessor.isStatic
         ? capabilities.supportsStaticInvoke
         : capabilities.supportsInstanceInvoke;
     return capabilityChecker(accessor.name, accessor.metadata);
   });
 }
 
 Iterable<ConstructorElement> _declaredConstructors(
     ClassElement classElement, _Capabilities capabilities) {
   return classElement.constructors.where((ConstructorElement constructor) {
+    if (constructor.isPrivate) return false;
     return capabilities.supportsNewInstance(
         constructor.name, constructor.metadata);
   });
 }
 
 _ClassDomain _createClassDomain(ClassElement type, _ReflectorDomain domain) {
   List<FieldElement> declaredFieldsOfClass =
-      _declaredFields(type, domain._capabilities).toList();
+      _extractDeclaredFields(type, domain._capabilities).toList();
   List<MethodElement> declaredMethodsOfClass =
-      _declaredMethods(type, domain._capabilities).toList();
+      _extractDeclaredMethods(type, domain._capabilities).toList();
+  List<ParameterElement> declaredParametersOfClass =
+      _extractDeclaredParameters(declaredMethodsOfClass);
   List<PropertyAccessorElement> declaredAndImplicitAccessorsOfClass =
       _declaredAndImplicitAccessors(type, domain._capabilities).toList();
   List<ConstructorElement> declaredConstructorsOfClass =
       _declaredConstructors(type, domain._capabilities).toList();
-  return new _ClassDomain(type, declaredFieldsOfClass, declaredMethodsOfClass,
-      declaredAndImplicitAccessorsOfClass, declaredConstructorsOfClass, domain);
-}
+  return new _ClassDomain(
+      type,
+      declaredFieldsOfClass,
+      declaredMethodsOfClass,
+      declaredParametersOfClass,
+      declaredAndImplicitAccessorsOfClass,
+      declaredConstructorsOfClass,
+      domain);
+}