Creates `reflectors`, as a meta-meta feature that enables dynamic selection of a "mirror system".

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';
@@ skipping 507 matching lines @@
   String _constConstructionCode(_ImportCollector importCollector) {
     String prefix = importCollector._getPrefix(_reflector.library);
     return "const $prefix.${_reflector.name}()";
   }
 
   /// Generate the code which will create a `ReflectorData` instance
   /// containing the mirrors and other reflection data which is needed for
   /// `_reflector` to behave correctly.
   String _generateCode(
       _ImportCollector importCollector, TransformLogger logger) {
-    Enumerator<ExecutableElement> members = new Enumerator<ExecutableElement>();
+    // Library related collections.
+    Enumerator<_LibraryDomain> libraries = new Enumerator<_LibraryDomain>();
+    Map<LibraryElement, _LibraryDomain> libraryMap =
+        <LibraryElement, _LibraryDomain>{};
+    Enumerator<TopLevelVariableElement> topLevelVariables =
+        new Enumerator<TopLevelVariableElement>();
+
+    // Class related collections.
     Enumerator<FieldElement> fields = new Enumerator<FieldElement>();
     Enumerator<ParameterElement> parameters =
         new Enumerator<ParameterElement>();
-    Enumerator<LibraryElement> libraries = new Enumerator<LibraryElement>();
     Set<String> instanceGetterNames = new Set<String>();
     Set<String> instanceSetterNames = new Set<String>();
 
+    // Library and class related collections.
+    Enumerator<ExecutableElement> members = new Enumerator<ExecutableElement>();
+
     // Fill in [libraries], [members], [fields], [parameters],
     // [instanceGetterNames], and [instanceSetterNames].
     for (LibraryElement library in _libraries) {
-      libraries.add(library);
+      _LibraryDomain libraryDomain = _createLibraryDomain(library, this);
+      libraries.add(libraryDomain);
+      libraryMap[library] = libraryDomain;
+      libraryDomain._declarations.forEach(members.add);
+      libraryDomain._declaredParameters.forEach(parameters.add);
+      libraryDomain._declaredVariables.forEach(topLevelVariables.add);
     }
     for (_ClassDomain classDomain in classes.domains) {
       // 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, for
       // non-static members) and all superclasses (which matters) to
@@ skipping 31 matching lines @@
           instanceGetterNames.add(instanceMember.name);
         } else {
           // `instanceMember` is a ConstructorElement.
           // Even though a generative constructor has a false
           // `isStatic`, we do not wish to include them among
           // instanceGetterNames, so we do nothing here.
         }
       });
     }
 
+    // Find the offsets of fields and of methods and functions in members.
+    int fieldsOffset = topLevelVariables.length;
+    int methodsOffset = fieldsOffset + fields.length;
+
     // Generate code for creation of class mirrors.
     String classMirrorsCode = _formatAsList(
         "m.ClassMirror",
         _capabilities._impliesTypes
             ? classes.domains.map((_ClassDomain classDomain) =>
-                _classMirrorCode(classDomain, fields, members, libraries,
-                    importCollector, logger))
+                _classMirrorCode(
+                    classDomain,
+                    fields,
+                    fieldsOffset,
+                    methodsOffset,
+                    members,
+                    libraries,
+                    libraryMap,
+                    importCollector,
+                    logger))
             : <String>[]);
 
     // Generate code for creation of getter and setter closures.
     String gettersCode = _formatAsMap(instanceGetterNames.map(_gettingClosure));
     String settersCode = _formatAsMap(instanceSetterNames.map(_settingClosure));
 
     bool reflectedTypeRequested = _capabilities._impliesReflectedType;
 
     // Generate code for creation of member mirrors.
     Iterable<String> methodsList =
@@ skipping 15 matching lines @@
         _formatAsList("Type", classes.map((ClassElement classElement) {
       return _typeCodeOfClass(classElement, importCollector);
     }));
 
     // Generate code for creation of library mirrors.
     String librariesCode;
     if (!_capabilities.supportsLibraries) {
       librariesCode = "null";
     } else {
       librariesCode = _formatAsList("m.LibraryMirror",
-          libraries.items.map((LibraryElement library) {
-        return _libraryMirrorCode(library, importCollector, logger);
+          libraries.items.map((_LibraryDomain library) {
+        return _libraryMirrorCode(library, members, topLevelVariables,
+            fields.length, importCollector, logger);
       }));
     }
 
     // Generate code for creation of parameter mirrors.
     Iterable<String> parametersList =
         parameters.items.map((ParameterElement element) {
       return _parameterMirrorCode(element, fields, members, importCollector,
           logger, reflectedTypeRequested);
     });
     String parameterMirrorsCode =
@@ skipping 34 matching lines @@
   int _computeReturnTypeIndex(ExecutableElement element, int descriptor) {
     if (!_capabilities._impliesTypes) return constants.NO_CAPABILITY_INDEX;
     int result = _computeTypeIndexBase(
         element.returnType.element,
         descriptor & constants.voidReturnTypeAttribute != 0,
         descriptor & constants.dynamicReturnTypeAttribute != 0,
         descriptor & constants.classReturnTypeAttribute != 0);
     return result;
   }
 
-  Iterable<PropertyAccessorElement> _gettersOfLibrary(LibraryElement library) {
-    return library.units.map((CompilationUnitElement part) {
-      Iterable<Element> getters = <Iterable<Element>>[
-        part.accessors
-            .where((PropertyAccessorElement accessor) => accessor.isGetter),
-        part.functions,
-        part.topLevelVariables
-      ].expand((Iterable<Element> elements) => elements);
-      return getters.where((Element getter) =>
-          _capabilities.supportsTopLevelInvoke(getter.name, getter.metadata));
-    }).expand((Iterable<Element> x) => x);
+  Iterable<ExecutableElement> _gettersOfLibrary(_LibraryDomain library) sync* {
+    yield* library._accessors
+        .where((PropertyAccessorElement accessor) => accessor.isGetter);
+    yield* library._declaredFunctions;
   }
 
-  Iterable<PropertyAccessorElement> _settersOfLibrary(LibraryElement library) {
-    return library.units.map((CompilationUnitElement part) {
-      Iterable setters = <Iterable<Element>>[
-        part.accessors
-            .where((PropertyAccessorElement accessor) => accessor.isSetter),
-        part.topLevelVariables
-            .where((TopLevelVariableElement variable) => !variable.isFinal)
-      ].expand((Iterable<Element> elements) => elements);
-      return setters.where((Element setter) =>
-          _capabilities.supportsTopLevelInvoke(setter.name, setter.metadata));
-    }).expand((Iterable<Element> x) => x);
+  Iterable<PropertyAccessorElement> _settersOfLibrary(_LibraryDomain library) {
+    return library._accessors
+        .where((PropertyAccessorElement accessor) => accessor.isSetter);
   }
 
   String _classMirrorCode(
       _ClassDomain classDomain,
       Enumerator<FieldElement> fields,
+      int fieldsOffset,
+      int methodsOffset,
       Enumerator<ExecutableElement> members,
-      Enumerator<LibraryElement> libraries,
+      Enumerator<_LibraryDomain> libraries,
+      Map<LibraryElement, _LibraryDomain> libraryMap,
       _ImportCollector importCollector,
       TransformLogger logger) {
+    int descriptor = _classDescriptor(classDomain._classElement);
+
     // Fields go first in [memberMirrors], so they will get the
     // same index as in [fields].
     Iterable<int> fieldsIndices =
         classDomain._declaredFields.map((FieldElement element) {
-      return fields.indexOf(element);
+      return fields.indexOf(element) + fieldsOffset;
     });
 
     // 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 use the index [constants.NO_CAPABILITY_INDEX]
       // for this declaration, because it is not yet supported.
       // Need to find the correct solution, though!
       int index = members.indexOf(element);
       return index == null
           ? constants.NO_CAPABILITY_INDEX
-          : index + fields.length;
+          : index + methodsOffset;
     });
 
-    String declarationsCode = "<int>[${constants
-        .NO_CAPABILITY_INDEX}]";
-    if (_capabilities._impliesDeclarations) {
-      List<int> declarationsIndices = <int>[]
-        ..addAll(fieldsIndices)
-        ..addAll(methodsIndices);
-      declarationsCode = _formatAsList("int", declarationsIndices);
-    }
+    String declarationsCode = _capabilities._impliesDeclarations
+        ? _formatAsList(
+            "int",
+            () sync* {
+              yield* fieldsIndices;
+              yield* methodsIndices;
+            }())
+        : "<int>[${constants.NO_CAPABILITY_INDEX}]";
 
     // All instance members belong to the behavioral interface, so they
     // also get an offset of `fields.length`.
     String instanceMembersCode = _formatAsList("int",
         classDomain._instanceMembers.map((ExecutableElement element) {
       // TODO(eernst) implement: The "magic" default constructor has
       // index: NO_CAPABILITY_INDEX; adjust this when support for it has
       // been implemented.
       int index = members.indexOf(element);
       return index == null
           ? constants.NO_CAPABILITY_INDEX
-          : index + fields.length;
+          : index + methodsOffset;
     }));
 
     // All static members belong to the behavioral interface, so they
     // also get an offset of `fields.length`.
     String staticMembersCode = _formatAsList("int",
         classDomain._staticMembers.map((ExecutableElement element) {
       int index = members.indexOf(element);
       return index == null
           ? constants.NO_CAPABILITY_INDEX
-          : index + fields.length;
+          : index + methodsOffset;
     }));
 
     ClassElement classElement = classDomain._classElement;
     ClassElement superclass = classes.superclassOf(classElement);
     // [Object]'s superclass is reported as `null`: it does not exist and
     // hence we cannot decide whether it's supported or unsupported; by
     // convention we make it supported and report it in the same way as
     // 'dart:mirrors'. Other superclasses use `NO_CAPABILITY_INDEX` to
     // indicate missing support.
     String superclassIndex = (classElement is! MixinApplication &&
@@ skipping 13 matching lines @@
         return 'r"${constructor.name}": $code';
       }));
     }
 
     String staticGettersCode = "{}";
     String staticSettersCode = "{}";
     if (classElement is! MixinApplication) {
       staticGettersCode = _formatAsMap([
         classDomain._declaredMethods
             .where((ExecutableElement element) => element.isStatic),
-        classDomain._declaredAndImplicitAccessors.where(
-            (PropertyAccessorElement element) =>
-                element.isStatic && element.isGetter)
+        classDomain._accessors.where((PropertyAccessorElement element) =>
+            element.isStatic && element.isGetter)
       ].expand((x) => x).map((ExecutableElement element) =>
           _staticGettingClosure(importCollector, classElement, element.name)));
-      staticSettersCode = _formatAsMap(classDomain._declaredAndImplicitAccessors
+      staticSettersCode = _formatAsMap(classDomain._accessors
           .where((PropertyAccessorElement element) =>
               element.isStatic && element.isSetter)
           .map((PropertyAccessorElement element) => _staticSettingClosure(
               importCollector, classElement, element.name)));
     }
 
     int mixinIndex;
     if (classElement.isMixinApplication) {
       // Named mixin application (using the syntax `class B = A with M;`).
       mixinIndex = classes.indexOf(classElement.mixins.last.element);
     } else {
       mixinIndex = (classElement is MixinApplication)
           ? classes.indexOf(classElement.mixin)
           : classes.indexOf(classElement);
     }
     if (mixinIndex == null) mixinIndex = constants.NO_CAPABILITY_INDEX;
 
     int ownerIndex = _capabilities.supportsLibraries
-        ? libraries.indexOf(classElement.library)
+        ? libraries.indexOf(libraryMap[classElement.library])
         : constants.NO_CAPABILITY_INDEX;
 
     String superinterfaceIndices = _formatAsList(
         'int',
         classElement.interfaces
             .map((InterfaceType type) => type.element)
             .where(classes.contains)
             .map(classes.indexOf));
 
     String classMetadataCode;
     if (_capabilities._supportsMetadata) {
       classMetadataCode = _extractMetadataCode(classElement, _resolver,
           importCollector, logger, _generatedLibraryId);
     } else {
       classMetadataCode = "null";
     }
 
     int classIndex = classes.indexOf(classElement);
 
     String result = 'new r.ClassMirrorImpl(r"${classDomain._simpleName}", '
-        'r"${_qualifiedName(classElement)}", $classIndex, '
+        'r"${_qualifiedName(classElement)}", $descriptor, $classIndex, '
         '${_constConstructionCode(importCollector)}, '
         '$declarationsCode, $instanceMembersCode, $staticMembersCode, '
         '$superclassIndex, $staticGettersCode, $staticSettersCode, '
         '$constructorsCode, $ownerIndex, $mixinIndex, '
         '$superinterfaceIndices, $classMetadataCode)';
     return result;
   }
 
   String _methodMirrorCode(
       ExecutableElement element,
@@ skipping 76 matching lines @@
           '${dartType.element}")';
     }
     return _typeCodeOfClass(dartType.element, importCollector);
   }
 
   String _typeCodeOfClass(
       ClassElement classElement, _ImportCollector importCollector) {
     if (classElement is MixinApplication && classElement.declaredName == null) {
       return 'new r.FakeType(r"${_qualifiedName(classElement)}")';
     }
-    if (classElement is! MixinApplication && classElement.type.isDynamic) {
-      return "dynamic";
-    }
+    if (classElement.type.isDynamic) return "dynamic";
     String prefix = importCollector._getPrefix(classElement.library);
     return "$prefix.${classElement.name}";
   }
 
-  String _libraryMirrorCode(LibraryElement library,
-      _ImportCollector importCollector, TransformLogger logger) {
+  String _libraryMirrorCode(
+      _LibraryDomain libraryDomain,
+      Enumerator<ExecutableElement> members,
+      Enumerator<TopLevelVariableElement> variables,
+      int fieldsLength,
+      _ImportCollector importCollector,
+      TransformLogger logger) {
+    LibraryElement library = libraryDomain._libraryElement;
+
     String gettersCode = _formatAsMap(
-        _gettersOfLibrary(library).map((PropertyAccessorElement getter) {
+        _gettersOfLibrary(libraryDomain).map((PropertyAccessorElement getter) {
       return _topLevelGettingClosure(importCollector, library, getter.name);
     }));
+
     String settersCode = _formatAsMap(
-        _settersOfLibrary(library).map((PropertyAccessorElement setter) {
+        _settersOfLibrary(libraryDomain).map((PropertyAccessorElement setter) {
       return topLevelSettingClosure(importCollector, library, setter.name);
     }));
 
+    // Fields go first in [memberMirrors], so they will get the
+    // same index as in [fields].
+    Iterable<int> variableIndices =
+        libraryDomain._declaredVariables.map((TopLevelVariableElement element) {
+      return variables.indexOf(element);
+    });
+
+    // 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 = libraryDomain._declarations
+        .where(_executableIsntImplicitGetterOrSetter)
+        .map((ExecutableElement element) {
+      int index = members.indexOf(element);
+      return index + fieldsLength;
+    });
+
+    String declarationsCode = "<int>[${constants.NO_CAPABILITY_INDEX}]";
+    if (_capabilities._impliesDeclarations) {
+      List<int> declarationsIndices = <int>[]
+        ..addAll(variableIndices)
+        ..addAll(methodsIndices);
+      declarationsCode = _formatAsList("int", declarationsIndices);
+    }
+
     // TODO(sigurdm) clarify: Find out how to get good uri's in a
     // transformer.
     // TODO(sigurdm) implement: Check for `uriCapability`.
     String uriCode = "null";
 
     String metadataCode;
     if (_capabilities._supportsMetadata) {
       metadataCode = _extractMetadataCode(
           library, _resolver, importCollector, logger, _generatedLibraryId);
     } else {
       metadataCode = "null";
     }
 
     return 'new r.LibraryMirrorImpl(r"${library.name}", $uriCode, '
-        '$gettersCode, $settersCode, $metadataCode)';
+        '${_constConstructionCode(importCollector)}, '
+        '$declarationsCode, $gettersCode, $settersCode, $metadataCode)';
   }
 
   String _parameterMirrorCode(
       ParameterElement element,
       Enumerator<FieldElement> fields,
       Enumerator<ExecutableElement> members,
       _ImportCollector importCollector,
       TransformLogger logger,
       bool reflectedTypeRequested) {
     int descriptor = _parameterDescriptor(element);
@@ skipping 302 matching lines @@
     closure = "(dynamic instance) => () => ~instance";
   } else {
     closure = "(dynamic instance) => (x) => instance ${getterName} x";
   }
   return 'r"${getterName}": $closure';
 }
 
 // Auxiliary function used by `_generateCode`.
 String _settingClosure(String setterName) {
   assert(setterName.substring(setterName.length - 1) == "=");
-  // The [setterName] includes the "=", remove it.
   String name = setterName.substring(0, setterName.length - 1);
-
-  return 'r"$setterName": (dynamic instance, value) => '
-      'instance.$name = value';
+  return 'r"$setterName": (dynamic instance, value) => instance.$name = value';
 }
 
 // Auxiliary function used by `_generateCode`.
 String _staticGettingClosure(_ImportCollector importCollector,
     ClassElement classElement, String getterName) {
   String className = classElement.name;
   String prefix = importCollector._getPrefix(classElement.library);
   // Operators cannot be static.
   return 'r"${getterName}": () => $prefix.$className.$getterName';
 }
@@ skipping 20 matching lines @@
 // Auxiliary function used by `_generateCode`.
 String topLevelSettingClosure(_ImportCollector importCollector,
     LibraryElement library, String setterName) {
   assert(setterName.substring(setterName.length - 1) == "=");
   // The [setterName] includes the "=", remove it.
   String name = setterName.substring(0, setterName.length - 1);
   String prefix = importCollector._getPrefix(library);
   return 'r"$setterName": (value) => $prefix.$name = value';
 }
 
+/// Information about reflectability for a given library.
+class _LibraryDomain {
+  /// Element describing the target library.
+  final LibraryElement _libraryElement;
+
+  /// Fields declared by [_libraryElement] and included for reflection support,
+  /// according to the reflector described by the [_reflectorDomain];
+  /// obtained by filtering `_libraryElement.fields`.
+  final Iterable<TopLevelVariableElement> _declaredVariables;
+
+  /// Methods which are declared by [_libraryElement] and included for
+  /// reflection support, according to the reflector described by
+  /// [_reflectorDomain]; obtained by filtering `_libraryElement.functions`.
+  final Iterable<FunctionElement> _declaredFunctions;
+
+  /// Formal parameters declared by one of the [_declaredFunctions].
+  final Iterable<ParameterElement> _declaredParameters;
+
+  /// Getters and setters possessed by [_libraryElement] and included for
+  /// reflection support, according to the reflector described by
+  /// [_reflectorDomain]; obtained by filtering `_libraryElement.accessors`.
+  /// Note that it includes declared as well as synthetic accessors, implicitly
+  /// created as getters/setters for fields.
+  final Iterable<PropertyAccessorElement> _accessors;
+
+  /// The reflector domain that holds [this] object as one of its
+  /// library domains.
+  final _ReflectorDomain _reflectorDomain;
+
+  _LibraryDomain(
+      this._libraryElement,
+      this._declaredVariables,
+      this._declaredFunctions,
+      this._declaredParameters,
+      this._accessors,
+      this._reflectorDomain);
+
+  String get _simpleName {
+    return _libraryElement.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 sync* {
+    yield* _declaredFunctions;
+    yield* _accessors;
+  }
+
+  String toString() {
+    return "LibraryDomain($_libraryElement)";
+  }
+
+  bool operator ==(Object other) {
+    if (other is _LibraryDomain) {
+      return _libraryElement == other._libraryElement &&
+          _reflectorDomain == other._reflectorDomain;
+    } else {
+      return false;
+    }
+  }
+
+  int get hashCode => _libraryElement.hashCode ^ _reflectorDomain.hashCode;
+}
+
 /// 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`.
+  /// 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
+  /// Methods which are declared by [_classElement] and included for
   /// reflection support, according to the reflector described by
-  /// [reflectorDomain]; obtained by filtering `classElement.methods`.
+  /// [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
+  /// Getters and setters possessed by [_classElement] and included for
   /// reflection support, according to the reflector described by
-  /// [reflectorDomain]; obtained by filtering `classElement.accessors`.
+  /// [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;
+  final Iterable<PropertyAccessorElement> _accessors;
 
-  /// Constructors declared by [classElement] and included for reflection
-  /// support, according to the reflector described by [reflectorDomain];
-  /// obtained by filtering `classElement.constructors`.
+  /// 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._declaredParameters,
-      this._declaredAndImplicitAccessors,
+      this._accessors,
       this._constructors,
       this._reflectorDomain);
 
   String get _simpleName {
     // TODO(eernst) clarify: Decide whether this should be simplified
     // by adding a method implementation to `MixinApplication`.
     if (_classElement.isMixinApplication) {
       // This is the case `class B = A with M;`.
       return _classElement.name;
     } else if (_classElement is MixinApplication) {
@@ skipping 19 matching lines @@
     }
   }
 
   /// 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, _accessors, _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>();
@@ skipping 190 matching lines @@
       // Handle API based capabilities.
       if ((capability is ec.TopLevelInvokeCapability) &&
           _supportsName(capability, methodName)) {
         return true;
       }
       if ((capability is ec.TopLevelInvokeMetaCapability) &&
           _supportsMeta(capability, metadata)) {
         return true;
       }
       // Quantifying capabilities do not influence the availability
-      // of reflection support for top level invocation.
+      // of reflection support for top-level invocation.
     }
 
     // All options exhausted, give up.
     return false;
   }
 
   bool _supportsStaticInvoke(List<ec.ReflectCapability> capabilities,
       String methodName, Iterable<DartObject> metadata) {
     for (ec.ReflectCapability capability in capabilities) {
       // Handle API based capabilities.
@@ skipping 280 matching lines @@
       // types (types whose name does not end in `..Impl`) declare the getter
       // `evaluationResult`.  Another possible choice of type would be
       // [VariableElementImpl], but with that one we would have to test
       // `isConst` as well.
       if (variable is ConstTopLevelVariableElementImpl) {
         EvaluationResultImpl result = variable.evaluationResult;
         if (result.value == null) return null; // Errors during evaluation.
         bool isOk = checkInheritance(result.value.type, focusClass.type);
         return isOk ? result.value.type.element : null;
       } else {
-        // Not a const top level variable, not relevant.
+        // Not a const top-level variable, not relevant.
         return null;
       }
     }
     // Otherwise [element] is some other construct which is not supported.
     //
     // TODO(eernst) clarify: We need to consider whether there could be some
     // other syntactic constructs that are incorrectly assumed by programmers
     // to be usable with Reflectable.  Currently, such constructs will silently
     // have no effect; it might be better to emit a diagnostic message (a
     // hint?) in order to notify the programmer that "it does not work".
@@ skipping 170 matching lines @@
       } else {
         _ReflectorDomain domain = getReflectorDomain(reflector);
         if (!domain._classes.contains(type)) {
           if (type.isMixinApplication) {
             // Iterate over all mixins in most-general-first order (so with
             // `class C extends B with M1, M2..` we visit `M1` then `M2`.
             ClassElement superclass = type.supertype.element;
             for (InterfaceType mixin in type.mixins) {
               ClassElement mixinElement = mixin.element;
               ClassElement subClass = mixin == type.mixins.last ? type : null;
-              String name = subClass == null ? null : type.name;
+              String name = subClass == null
+                  ? null
+                  : (type.isMixinApplication ? type.name : null);
               MixinApplication mixinApplication = new MixinApplication(
                   name, superclass, mixinElement, type.library, subClass);
               domain._classes.add(mixinApplication);
               superclass = mixinApplication;
             }
           } else {
             domain._classes.add(type);
           }
           addLibrary(type.library, reflector);
           // We need to ensure that the [importCollector] has indeed added
@@ skipping 67 matching lines @@
         addLibrary(library, reflector);
       }
 
       for (CompilationUnitElement unit in library.units) {
         for (ClassElement type in unit.types) {
           for (ClassElement reflector
               in getReflectors(_qualifiedName(type), type.metadata)) {
             addClassDomain(type, reflector);
           }
         }
+        for (FunctionElement function in unit.functions) {
+          for (ClassElement reflector in getReflectors(
+              _qualifiedFunctionName(function), function.metadata)) {
+            // We just add the library here, the function itself will be
+            // supported using `invoke` and `declarations` of that library
+            // mirror.
+            addLibrary(library, reflector);
+          }
+        }
       }
     }
 
     return new ReflectionWorld(_resolver, dataId, domains.values.toList(),
         reflectableLibrary, entryPoint, importCollector);
   }
 
   /// Returns the [ReflectCapability] denoted by the given [initializer].
   ec.ReflectCapability _capabilityOfExpression(LibraryElement capabilityLibrary,
       Expression expression, LibraryElement containingLibrary) {
@@ skipping 347 matching lines @@
 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
+/// class.
+int _classDescriptor(ClassElement element) {
+  int result = constants.clazz;
+  if (element.isPrivate) result |= constants.privateAttribute;
+  if (element.isSynthetic) result |= constants.syntheticAttribute;
+  if (element.isAbstract) result |= constants.abstractAttribute;
+  if (element.isEnum) result |= constants.enumAttribute;
+  return result;
+}
+
+/// 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;
     // We will get `false` from `element.isFinal` in this case, but with
     // a mirror from 'dart:mirrors' it is considered to be "implicitly
     // final", so we follow that and ignore `element.isFinal`.
@@ skipping 332 matching lines @@
       metadataParts.add("const $prefix.$constructor($arguments)");
     } else {
       // A field reference.
       metadataParts.add("$prefix.${annotationNode.name}");
     }
   }
 
   return _formatAsList("Object", metadataParts);
 }
 
+/// Returns the top level variables declared in the given [libraryElement],
+/// filtering them such that the returned ones are those that are supported
+/// by [capabilities].
+Iterable<TopLevelVariableElement> _extractDeclaredVariables(
+    LibraryElement libraryElement, _Capabilities capabilities) sync* {
+  for (CompilationUnitElement unit in libraryElement.units) {
+    for (TopLevelVariableElement variable in unit.topLevelVariables) {
+      if (variable.isPrivate || variable.isSynthetic) continue;
+      // TODO(eernst) clarify: Do we want to subsume variables under invoke?
+      if (capabilities.supportsTopLevelInvoke(
+          variable.name, variable.metadata)) {
+        yield variable;
+      }
+    }
+  }
+}
+
+/// Returns the top level functions declared in the given [libraryElement],
+/// filtering them such that the returned ones are those that are supported
+/// by [capabilities].
+Iterable<FunctionElement> _extractDeclaredFunctions(
+    LibraryElement libraryElement, _Capabilities capabilities) sync* {
+  for (CompilationUnitElement unit in libraryElement.units) {
+    for (FunctionElement function in unit.functions) {
+      if (function.isPrivate) continue;
+      if (capabilities.supportsTopLevelInvoke(
+          function.name, function.metadata)) {
+        yield function;
+      }
+    }
+  }
+}
+
+/// Returns the parameters declared in the given [declaredFunctions] as well
+/// as the setters from the given [accessors].
+Iterable<ParameterElement> _extractDeclaredFunctionParameters(
+    Iterable<FunctionElement> declaredFunctions,
+    Iterable<ExecutableElement> accessors) {
+  List<ParameterElement> result = <ParameterElement>[];
+  for (FunctionElement declaredFunction in declaredFunctions) {
+    result.addAll(declaredFunction.parameters);
+  }
+  for (ExecutableElement accessor in accessors) {
+    if (accessor is PropertyAccessorElement && accessor.isSetter) {
+      result.addAll(accessor.parameters);
+    }
+  }
+  return result;
+}
+
+/// Returns the declared fields in the given [classElement], filtered such
+/// that the returned ones are the ones that are supported by [capabilities].
 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);
   });
 }
 
+/// Returns the declared methods in the given [classElement], filtered such
+/// that the returned ones are the ones that are supported by [capabilities].
 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);
   });
 }
 
+/// Returns the declared parameters in the given [declaredMethods] and
+/// [declaredConstructors], as well as the ones from the setters in
+/// [accessors].
 Iterable<ParameterElement> _extractDeclaredParameters(
     Iterable<MethodElement> declaredMethods,
     Iterable<ConstructorElement> declaredConstructors,
     Iterable<PropertyAccessorElement> accessors) {
   List<ParameterElement> result = <ParameterElement>[];
   for (MethodElement declaredMethod in declaredMethods) {
     result.addAll(declaredMethod.parameters);
   }
   for (ConstructorElement declaredConstructor in declaredConstructors) {
     result.addAll(declaredConstructor.parameters);
   }
   for (PropertyAccessorElement accessor in accessors) {
     if (accessor.isSetter) {
       result.addAll(accessor.parameters);
     }
   }
   return result;
 }
 
+/// Returns the accessors from the given [libraryElement], filtured such that
+/// the returned ones are the ones that are supported by [capabilities].
+Iterable<ExecutableElement> _extractLibraryAccessors(
+    LibraryElement libraryElement, _Capabilities capabilities) sync* {
+  for (CompilationUnitElement unit in libraryElement.units) {
+    for (PropertyAccessorElement accessor in unit.accessors) {
+      if (accessor.isPrivate) continue;
+      if (capabilities.supportsTopLevelInvoke(
+          accessor.name, accessor.metadata)) {
+        yield accessor;
+      }
+    }
+  }
+}
+
 /// 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(
+Iterable<PropertyAccessorElement> _extractAccessors(
     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(
+/// Returns the declared constructors from [classElement], filtered such that
+/// the returned ones are the ones that are supported by [capabilities].
+Iterable<ConstructorElement> _extractDeclaredConstructors(
     ClassElement classElement, _Capabilities capabilities) {
   return classElement.constructors.where((ConstructorElement constructor) {
     if (constructor.isPrivate) return false;
     return capabilities.supportsNewInstance(
         constructor.name, constructor.metadata);
   });
 }
 
+_LibraryDomain _createLibraryDomain(
+    LibraryElement library, _ReflectorDomain domain) {
+  List<TopLevelVariableElement> declaredVariablesOfLibrary =
+      _extractDeclaredVariables(library, domain._capabilities).toList();
+  List<FunctionElement> declaredFunctionsOfLibrary =
+      _extractDeclaredFunctions(library, domain._capabilities).toList();
+  List<PropertyAccessorElement> accessorsOfLibrary =
+      _extractLibraryAccessors(library, domain._capabilities);
+  List<ParameterElement> declaredParametersOfLibrary =
+      _extractDeclaredFunctionParameters(
+          declaredFunctionsOfLibrary, accessorsOfLibrary);
+  return new _LibraryDomain(
+      library,
+      declaredVariablesOfLibrary,
+      declaredFunctionsOfLibrary,
+      declaredParametersOfLibrary,
+      accessorsOfLibrary,
+      domain);
+}
+
 _ClassDomain _createClassDomain(ClassElement type, _ReflectorDomain domain) {
   if (type is MixinApplication) {
     List<FieldElement> declaredFieldsOfClass =
         _extractDeclaredFields(type.mixin, domain._capabilities)
             .where((FieldElement e) => !e.isStatic)
             .toList();
     List<MethodElement> declaredMethodsOfClass =
         _extractDeclaredMethods(type.mixin, domain._capabilities)
             .where((MethodElement e) => !e.isStatic)
             .toList();
     List<PropertyAccessorElement> declaredAndImplicitAccessorsOfClass =
-        _declaredAndImplicitAccessors(type.mixin, domain._capabilities)
-            .toList();
+        _extractAccessors(type.mixin, domain._capabilities).toList();
     List<ConstructorElement> declaredConstructorsOfClass =
         new List<ConstructorElement>();
     List<ParameterElement> declaredParametersOfClass =
         _extractDeclaredParameters(declaredMethodsOfClass,
             declaredConstructorsOfClass, declaredAndImplicitAccessorsOfClass);
 
     return new _ClassDomain(
         type,
         declaredFieldsOfClass,
         declaredMethodsOfClass,
         declaredParametersOfClass,
         declaredAndImplicitAccessorsOfClass,
         declaredConstructorsOfClass,
         domain);
   }
 
   List<FieldElement> declaredFieldsOfClass =
       _extractDeclaredFields(type, domain._capabilities).toList();
   List<MethodElement> declaredMethodsOfClass =
       _extractDeclaredMethods(type, domain._capabilities).toList();
   List<PropertyAccessorElement> declaredAndImplicitAccessorsOfClass =
-      _declaredAndImplicitAccessors(type, domain._capabilities).toList();
+      _extractAccessors(type, domain._capabilities).toList();
   List<ConstructorElement> declaredConstructorsOfClass =
-      _declaredConstructors(type, domain._capabilities).toList();
+      _extractDeclaredConstructors(type, domain._capabilities).toList();
   List<ParameterElement> declaredParametersOfClass = _extractDeclaredParameters(
       declaredMethodsOfClass,
       declaredConstructorsOfClass,
       declaredAndImplicitAccessorsOfClass);
   return new _ClassDomain(
       type,
       declaredFieldsOfClass,
       declaredMethodsOfClass,
       declaredParametersOfClass,
       declaredAndImplicitAccessorsOfClass,
@@ skipping 50 matching lines @@
   String get name {
     if (declaredName != null) return declaredName;
     if (superclass is MixinApplication) {
       return "${superclass.name}, ${_qualifiedName(mixin)}";
     } else {
       return "${_qualifiedName(superclass)} with ${_qualifiedName(mixin)}";
     }
   }
 
   @override
+  String get displayName => name;
+
+  @override
   List<InterfaceType> get interfaces => <InterfaceType>[];
 
   @override
   List<ElementAnnotation> get metadata => <ElementAnnotation>[];
 
   @override
-  bool get isSynthetic => declaredName != null;
+  bool get isSynthetic => declaredName == null;
 
   // Note that the `InterfaceTypeImpl` may well call methods on this
   // `MixinApplication` whose body is `_unImplemented()`, but it still provides
   // a slightly better service than leaving this method `_unImplemented()`:
   // We are allowed to take one more step, which may be enough.
   @override
   InterfaceType get type => new InterfaceTypeImpl(this);
 
   @override
   InterfaceType get supertype {
@@ skipping 12 matching lines @@
   }
 
   /// Returns true iff this class was declared using the syntax
   /// `class B = A with M;`, i.e., if it is an explicitly named mixin
   /// application. We do not create instances of this class in that
   /// case.
   @override
   bool get isMixinApplication => declaredName != null;
 
   @override
+  bool get isAbstract => !isMixinApplication || mixin.isAbstract;
+
+  @override
+  bool get isEnum => false;
+
+  @override
   NamedCompilationUnitMember computeNode() =>
       declaredName != null ? subclass.computeNode() : null;
 
   @override
   bool operator ==(Object object) {
     return object is MixinApplication &&
         superclass == object.superclass &&
         mixin == object.mixin &&
         library == object.library &&
         subclass == object.subclass;
@@ skipping 21 matching lines @@
   @override
   bool get hasNonFinalField => _unImplemented();
 
   @override
   bool get hasReferenceToSuper => _unImplemented();
 
   @override
   bool get hasStaticMember => _unImplemented();
 
   @override
-  bool get isAbstract => _unImplemented();
-
-  @override
-  bool get isEnum => _unImplemented();
-
-  @override
   bool get isOrInheritsProxy => _unImplemented();
 
   @override
   bool get isProxy => _unImplemented();
 
   @override
   bool get isTypedef => _unImplemented();
 
   @override
   bool get isValidMixin => _unImplemented();
@@ skipping 75 matching lines @@
   }
 
   // This seems to be the defined behaviour according to dart:mirrors.
   @override
   bool get isPrivate => false;
 
   @override
   get context => _unImplemented();
 
   @override
-  String get displayName => _unImplemented();
-
-  @override
   Element get enclosingElement => _unImplemented();
 
   @override
   int get id => _unImplemented();
 
   @override
   bool get isDeprecated => _unImplemented();
 
   @override
   bool get isOverride => _unImplemented();
@@ skipping 36 matching lines @@
 
   @override
   void visitChildren(ElementVisitor visitor) => _unImplemented();
 }
 
 String _qualifiedName(ClassElement classElement) {
   return classElement == null
       ? "null"
       : "${classElement.library.name}.${classElement.name}";
 }
+
+String _qualifiedFunctionName(FunctionElement functionElement) {
+  return functionElement == null
+      ? "null"
+      : "${functionElement.library.name}.${functionElement.name}";
+}