Uses analyzer ^0.27.2 rather than a fixed 0.27.1

reflectable/lib/src/transformer_implementation.dart

 // Copyright (c) 2016, 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:developer' as developer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
@@ skipping 640 matching lines @@
     String optionalsWithDefaults =
         new Iterable.generate(optionalPositionalCount, (int i) {
       ParameterElement parameterElement =
           constructor.parameters[requiredPositionalCount + i];
       FormalParameter parameterNode = parameterElement.computeNode();
       String defaultValueCode = "";
       if (parameterNode is DefaultFormalParameter &&
           parameterNode.defaultValue != null) {
         defaultValueCode = " = ${_extractConstantCode(
             parameterNode.defaultValue,
-            parameterElement.library,
             importCollector, logger, _generatedLibraryId, _resolver)}";
       }
       return "${parameterNames[requiredPositionalCount + i]}"
           "$defaultValueCode";
     }).join(", ");
 
     String namedWithDefaults =
         new Iterable.generate(namedParameterNames.length, (int i) {
       // Note that the use of `requiredPositionalCount + i` below relies
       // on a language design where no parameter list can include
       // both optional positional and named parameters, so if there are
       // any named parameters then all optional parameters are named.
       ParameterElement parameterElement =
           constructor.parameters[requiredPositionalCount + i];
       FormalParameter parameterNode = parameterElement.computeNode();
       String defaultValueCode = "";
       if (parameterNode is DefaultFormalParameter &&
           parameterNode.defaultValue != null) {
         defaultValueCode = ": ${_extractConstantCode(
             parameterNode.defaultValue,
-            parameterElement.library,
             importCollector, logger, _generatedLibraryId, _resolver)}";
       }
       return "${namedParameterNames[i]}$defaultValueCode";
     }).join(", ");
 
     String optionalArguments = new Iterable.generate(optionalPositionalCount,
         (int i) => parameterNames[i + requiredPositionalCount]).join(", ");
     String namedArguments =
         namedParameterNames.map((String name) => "$name: $name").join(", ");
 
@@ skipping 87 matching lines @@
       if (!_isImportableLibrary(library, _generatedLibraryId, _resolver))
         return;
       importCollector._addLibrary(library);
       uncheckedAddLibrary(library);
     }
 
     // Fill in [libraries], [typeParameters], [members], [fields],
     // [parameters], [instanceGetterNames], and [instanceSetterNames].
     _libraries.items.forEach(uncheckedAddLibrary);
     classes.forEach((ClassElement classElement) {
+      LibraryElement classLibrary = classElement.library;
       if (!libraries.items.any((_LibraryDomain libraryDomain) =>
-          libraryDomain._libraryElement == classElement.library)) {
-        addLibrary(classElement.library);
+          libraryDomain._libraryElement == classLibrary)) {
+        addLibrary(classLibrary);
       }
       classElement.typeParameters.forEach(typeParameters.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);
 
@@ skipping 53 matching lines @@
           // `isStatic`, we do not wish to include them among
           // instanceGetterNames, so we do nothing here.
         }
       });
     }
 
     // Add classes used as bounds for type variables, if needed.
     if (_capabilities._impliesTypes && _capabilities._impliesTypeAnnotations) {
       void addClass(ClassElement classElement) {
         classes.add(classElement);
-        if (!libraries.items.contains(classElement.library)) {
-          uncheckedAddLibrary(classElement.library);
+        LibraryElement classLibrary = classElement.library;
+        if (!libraries.items.contains(classLibrary)) {
+          uncheckedAddLibrary(classLibrary);
         }
       }
 
       bool hasObject = false;
       bool mustHaveObject = false;
       Set<ClassElement> classesToAdd = new Set<ClassElement>();
       ClassElement anyClassElement;
       for (ClassElement classElement in classes) {
         if (classElement.type.isObject) {
           hasObject = true;
@@ skipping 1049 matching lines @@
         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);
+      defaultValueCode = _extractConstantCode(parameterNode.defaultValue,
+          importCollector, logger, _generatedLibraryId, _resolver);
     }
     String parameterSymbolCode = descriptor & constants.namedAttribute != 0
         ? "#${element.name}"
         : "null";
 
     return 'new r.ParameterMirrorImpl(r"${element.name}", $descriptor, '
         '$ownerIndex, ${_constConstructionCode(importCollector, logger)}, '
         '$classMirrorIndex, $reflectedTypeIndex, $dynamicReflectedTypeIndex, '
         '$metadataCode, $defaultValueCode, $parameterSymbolCode)';
   }
@@ skipping 595 matching lines @@
       // fully when the set of supported classes was computed.
     }
 
     // All options exhausted, give up.
     return false;
   }
 
   Iterable<DartObjectImpl> _getEvaluatedMetadata(
       Iterable<ElementAnnotation> metadata) {
     return metadata.map((ElementAnnotationImpl elementAnnotation) {
-      EvaluationResultImpl evaluation = elementAnnotation.evaluationResult;
+      EvaluationResultImpl evaluation =
+          _annotationEvaluationResult(elementAnnotation);
       if (evaluation != null) return evaluation.value;
       // The `evaluationResult` from a getter is `null`, so we have to deal
       // with that case separately.
       Element element = elementAnnotation.element;
       if (element is PropertyAccessorElement &&
           element.isGetter &&
           element.isSynthetic) {
         return element.variable.constantValue;
       } else if (element is ConstructorElementImpl) {
         DartType dartType = element.returnType;
@@ skipping 336 matching lines @@
   /// across all usage locations for reflectable.dart, so we cannot easily
   /// predict all the possible URIs that could be used to import
   /// reflectable.dart; and it would be awkward to require that all user
   /// programs must use exactly one specific URI to import
   /// reflectable.dart.  So we use [Reflectable.thisClassId] which is very
   /// unlikely to occur with the same value elsewhere by accident.
   bool _equalsClassReflectable(ClassElement type) {
     FieldElement idField = type.getField("thisClassId");
     if (idField == null || !idField.isStatic) return false;
     if (idField is ConstFieldElementImpl) {
-      EvaluationResultImpl idResult = idField.evaluationResult;
+      EvaluationResultImpl idResult = _constFieldEvaluationResult(idField);
       if (idResult != null) {
         return idField.constantValue.toStringValue() ==
             reflectable_class_constants.id;
       }
       // idResult == null: analyzer/.../element.dart specifies that this can
       // occur "if this variable is not a 'const' variable, if it does not
       // have an initializer, or if the compilation unit containing the
       // variable has not been resolved". The third case should not occur with
-      // the approach we use to obtain a `LibraryElement`, so it is not the
+      // the approach we use to obtain the `LibraryElement` for the library
+      // 'package:reflectable/reflectable.dart', so it is not the
       // right declaration we are looking at.
     }
-    // Not a const field, or failed the test, cannot be the right class.
+    // Not a const field, or failed the `id` test: cannot be the right class.
     return false;
   }
 
   /// Returns the ClassElement in the target program which corresponds to class
   /// [Reflectable].
   ClassElement _findReflectableClassElement(LibraryElement reflectableLibrary) {
     for (CompilationUnitElement unit in reflectableLibrary.units) {
       for (ClassElement type in unit.types) {
         if (type.name == reflectable_class_constants.name &&
             _equalsClassReflectable(type)) {
@@ skipping 64 matching lines @@
       return isOk ? element.enclosingElement.type.element : null;
     } else if (element is PropertyAccessorElement) {
       PropertyInducingElement variable = element.variable;
       // Surprisingly, we have to use [ConstTopLevelVariableElementImpl]
       // here (or a similar type).  This is because none of the "public name"
       // 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;
+        EvaluationResultImpl result =
+            _constTopLevelVariableEvaluationResult(variable);
         // Handle errors during evaluation. In general `evaluationResult` is
         // null for (1) non-const variables, (2) variables without an
         // initializer, and (3) unresolved libraries; (3) should not occur
         // because of the approach we use to get the resolver; we will not
         // see (1) because we have checked the type of `variable`; and (2)
         // would mean that the value is actually null, which we will also
         // reject as irrelevant.
         if (result?.value == null) return null;
         bool isOk = checkInheritance(result.value.type, focusClass.type);
         return isOk ? result.value.type.element : null;
       } else if (variable is ConstFieldElementImpl) {
         // A [ConstFieldElementImpl] is also used for non-const (final)
         // fields, so we could also check `variable.isConst`; however, if
         // we have non-const metadata then the program (pre- and post-
         // transformed) will be rejected by the analyzer and the compilers,
         // which means that it is unimportant for us to reject that case.
-        EvaluationResultImpl result = variable.evaluationResult;
+        EvaluationResultImpl result = _constFieldEvaluationResult(variable);
         if (result?.value == null) return null;
         bool isOk = checkInheritance(result.value.type, focusClass.type);
         return isOk ? result.value.type.element : null;
       } else {
         _logger.fine("Ignoring unsupported metadata form ${element}",
             asset: _resolver.getSourceAssetId(element),
             span: _resolver.getSourceSpan(element));
         return null;
       }
     }
@@ skipping 35 matching lines @@
     ConstructorElement globalQuantifyCapabilityConstructor = capabilityLibrary
         .getType("GlobalQuantifyCapability")
         .getNamedConstructor("");
     ConstructorElement globalQuantifyMetaCapabilityConstructor =
         capabilityLibrary
             .getType("GlobalQuantifyMetaCapability")
             .getNamedConstructor("");
 
     for (LibraryElement library in _resolver.libraries) {
       for (ImportElement import in library.imports) {
+        if (import.importedLibrary != reflectableLibrary) continue;
         for (ElementAnnotationImpl metadatum in import.metadata) {
           if (metadatum.element == globalQuantifyCapabilityConstructor) {
-            EvaluationResultImpl evaluation = metadatum.evaluationResult;
+            EvaluationResultImpl evaluation =
+                _annotationEvaluationResult(metadatum);
             if (evaluation != null && evaluation.value != null) {
               DartObjectImpl value = evaluation.value;
               String pattern = value.fields["classNamePattern"].toStringValue();
               if (pattern == null) {
                 // TODO(sigurdm) implement: Create a span for the annotation
                 // rather than the import.
                 _warn(WarningKind.badNamePattern,
                     "The classNamePattern must be a string", import);
                 continue;
               }
@@ skipping 10 matching lines @@
                         found,
                     import);
                 continue;
               }
               globalPatterns
                   .putIfAbsent(new RegExp(pattern), () => <ClassElement>[])
                   .add(reflector);
             }
           } else if (metadatum.element ==
               globalQuantifyMetaCapabilityConstructor) {
-            EvaluationResultImpl evaluation = metadatum.evaluationResult;
+            EvaluationResultImpl evaluation =
+                _annotationEvaluationResult(metadatum);
             if (evaluation?.value != null) {
               DartObjectImpl value = evaluation.value;
               Object metadataFieldValue =
                   value.fields["metadataType"].toTypeValue().element;
               if (metadataFieldValue == null ||
                   value.fields["metadataType"].type.element != typeClass) {
                 // TODO(sigurdm) implement: Create a span for the annotation.
                 _warn(
                     WarningKind.badMetadata,
                     "The metadata must be a Type. "
@@ skipping 128 matching lines @@
     Map<ClassElement, List<ClassElement>> globalMetadata =
         new Map<ClassElement, List<ClassElement>>();
 
     final LibraryElement capabilityLibrary =
         _resolver.getLibraryByName("reflectable.capability");
 
     /// Gets the [ReflectorDomain] associated with [reflector], or creates
     /// it if none exists.
     _ReflectorDomain getReflectorDomain(ClassElement reflector) {
       return domains.putIfAbsent(reflector, () {
+        LibraryElement reflectorLibrary = reflector.library;
         _Capabilities capabilities =
             _capabilitiesOf(capabilityLibrary, reflector);
-        assert(_isImportableLibrary(reflector.library, dataId, _resolver));
-        importCollector._addLibrary(reflector.library);
+        assert(_isImportableLibrary(reflectorLibrary, dataId, _resolver));
+        importCollector._addLibrary(reflectorLibrary);
         return new _ReflectorDomain(_resolver, dataId, reflector, capabilities);
       });
     }
 
     /// Adds [library] to the supported libraries of [reflector].
     void addLibrary(LibraryElement library, ClassElement reflector) {
       _ReflectorDomain domain = getReflectorDomain(reflector);
       if (domain._capabilities._supportsLibraries) {
         assert(_isImportableLibrary(library, dataId, _resolver));
         importCollector._addLibrary(library);
@@ skipping 37 matching lines @@
           // generated library, even in cases where the transformed program
           // will not get library support.
           // TODO(eernst) clarify: Maybe the following statement could be moved
           // out of the `if` in `addLibrary` such that we don't have to have
           // an extra copy of it here.
           importCollector._addLibrary(type.library);
         }
       }
     }
 
-    /// Runs through a list of metadata, and finds any Reflectors, and
+    /// Runs through [metadata] and finds all reflectors as well as
     /// objects that are associated with reflectors via
-    /// GlobalQuantifyMetaCapability and GlobalQuantifyCapability.
+    /// [GlobalQuantifyMetaCapability] or [GlobalQuantifyCapability].
     /// [qualifiedName] is the name of the library or class annotated by
-    /// metadata.
+    /// [metadata].
     Iterable<ClassElement> getReflectors(
         String qualifiedName, List<ElementAnnotation> metadata) {
       List<ClassElement> result = <ClassElement>[];
 
       for (ElementAnnotationImpl metadatum in metadata) {
         EvaluationResultImpl evaluation = metadatum.evaluationResult;
         DartObject value = evaluation?.value;
 
         // Test if the type of this metadata is associated with any reflectors
         // via GlobalQuantifyMetaCapability.
@@ skipping 419 matching lines @@
     if (reflectableLibrary == null) {
       // Stop and do not consumePrimary, i.e., let the original source
       // pass through without changes.
       _logger.info("Ignoring entry point $currentEntryPoint that does not "
           "include the library 'package:reflectable/reflectable.dart'");
       if (const bool.fromEnvironment("reflectable.pause.at.exit")) {
         _processedEntryPointCount++;
       }
       return;
     }
+    reflectableLibrary = _resolvedLibraryOf(reflectableLibrary);
 
     LibraryElement entryPointLibrary = _resolver.getLibrary(asset.id);
     if (const bool.fromEnvironment("reflectable.print.entry.point")) {
       print("Starting transformation of '$currentEntryPoint'.");
     }
 
     ReflectionWorld world =
         _computeWorld(reflectableLibrary, entryPointLibrary, asset.id);
     if (world == null) {
       // Errors have already been reported during `_computeWorld`.
@@ skipping 21 matching lines @@
 
     // Generate a new file with the name of the entry-point, whose main
     // initializes the reflection data, and calls the main from
     // [originalEntryPointId].
     String newEntryPoint =
         _generateNewEntryPoint(world, asset.id, originalEntryPointFilename);
     transform.addOutput(new Asset.fromString(asset.id, newEntryPoint));
     if (const bool.fromEnvironment("reflectable.pause.at.exit")) {
       _processedEntryPointCount++;
     }
+    if (const bool.fromEnvironment("reflectable.print.resolved.libraries")) {
+      print("Resolved libraries for $currentEntryPoint: "
+          "${_resolvedLibraries.length}/${_resolver.libraries.length}");
+    }
     _resolver.release();
 
     if (const bool.fromEnvironment("reflectable.pause.at.exit")) {
       if (_processedEntryPointCount ==
           const int.fromEnvironment("reflectable.pause.at.exit.count")) {
         print("Transformation complete, pausing at exit.");
         developer.debugger();
       }
     }
   }
@@ skipping 175 matching lines @@
 
 String _formatAsDynamicList(Iterable parts) => "[${parts.join(", ")}]";
 
 String _formatAsMap(Iterable parts) => "{${parts.join(", ")}}";
 
 /// Returns a [String] containing code that will evaluate to the same
 /// value when evaluated in the generated file as the given [expression]
 /// would evaluate to in [originatingLibrary].
 String _extractConstantCode(
     Expression expression,
-    LibraryElement originatingLibrary,
     _ImportCollector importCollector,
     TransformLogger logger,
     AssetId generatedLibraryId,
     Resolver resolver) {
   String helper(Expression expression) {
     if (expression is ListLiteral) {
       Iterable<String> elements =
           expression.elements.map((Expression subExpression) {
         return helper(subExpression);
       });
@@ skipping 11 matching lines @@
     } else if (expression is InstanceCreationExpression) {
       String constructor = expression.constructorName.toSource();
       if (_isPrivateName(constructor)) {
         logger.error("Cannot access private name $constructor, "
             "needed for expression $expression");
       }
       LibraryElement libraryOfConstructor = expression.staticElement.library;
       if (_isImportableLibrary(
           libraryOfConstructor, generatedLibraryId, resolver)) {
         importCollector._addLibrary(libraryOfConstructor);
-        String prefix =
-            importCollector._getPrefix(expression.staticElement.library);
+        String prefix = importCollector._getPrefix(libraryOfConstructor);
         // TODO(sigurdm) implement: Named arguments.
         String arguments =
             expression.argumentList.arguments.map((Expression argument) {
           return helper(argument);
         }).join(", ");
         // TODO(sigurdm) feature: Type arguments.
         if (_isPrivateName(constructor)) {
           logger.error("Cannot access private name $constructor, "
               "needed for expression $expression");
         }
@@ skipping 55 matching lines @@
     } else if (expression is MethodInvocation) {
       // We only handle "identical(a, b)".
       assert(expression.target == null);
       assert(expression.methodName.token.lexeme == "identical");
       NodeList arguments = expression.argumentList.arguments;
       assert(arguments.length == 2);
       String a = helper(arguments[0]);
       String b = helper(arguments[1]);
       return "identical($a, $b)";
     } else if (expression is NamedExpression) {
-      String value = _extractConstantCode(
-          expression.expression,
-          originatingLibrary,
-          importCollector,
-          logger,
-          generatedLibraryId,
-          resolver);
+      String value = _extractConstantCode(expression.expression,
+          importCollector, logger, generatedLibraryId, resolver);
       return "${expression.name} $value";
     } else {
       assert(expression is IntegerLiteral ||
           expression is BooleanLiteral ||
           expression is StringLiteral ||
           expression is NullLiteral ||
           expression is SymbolLiteral ||
           expression is DoubleLiteral ||
           expression is TypedLiteral);
       return expression.toSource();
     }
   }
+
   return helper(expression);
 }
 
 /// The names of the libraries that can be accessed with a 'dart:x' import uri.
 Set<String> sdkLibraryNames = new Set.from([
   "async",
   "collection",
   "convert",
   "core",
   "developer",
@@ skipping 72 matching lines @@
       // Some internal constants (mainly in dart:html) cannot be resolved by
       // the analyzer. Ignore them.
       // TODO(sigurdm) clarify: Investigate this, and see if these constants can
       // somehow be included.
       logger.fine("Ignoring unresolved metadata $annotationNode",
           asset: resolver.getSourceAssetId(element),
           span: resolver.getSourceSpan(element));
       continue;
     }
 
-    LibraryElement library = annotationNode.element.library;
     if (!_isImportable(annotationNode.element, dataId, resolver)) {
       // Private constants, and constants made of classes in internal libraries
       // cannot be represented.
       // Skip them.
       // TODO(sigurdm) clarify: Investigate this, and see if these constants can
       // somehow be included.
       logger.fine("Ignoring unrepresentable metadata $annotationNode",
           asset: resolver.getSourceAssetId(element),
           span: resolver.getSourceSpan(element));
       continue;
     }
-    importCollector._addLibrary(library);
-    String prefix = importCollector._getPrefix(library);
+    LibraryElement annotationLibrary = annotationNode.element.library;
+    importCollector._addLibrary(annotationLibrary);
+    String prefix = importCollector._getPrefix(annotationLibrary);
     if (annotationNode.arguments != null) {
       // A const constructor.
       Identifier annotationName = annotationNode.name;
       String name;
       if (annotationName is SimpleIdentifier) {
         name = "$annotationName";
       } else if (annotationName is PrefixedIdentifier) {
         // The annotation is on the form `@p.C(..)` where `p` is a library
         // prefix, or it is on the form `@C.n(..)` where `C` is a class and
         // `n` a named constructor.
         if (annotationName.prefix.staticElement is PrefixElement) {
           // We must replace the library prefix by the appropriate prefix for
           // code in the generated library, so we omit `prefix`.
           name = "${annotationName.identifier}";
         } else {
           // We must preserve the prefix which is a class name.
           name = "$annotationName";
         }
         // In both cases we must include the library prefix.
         prefix = importCollector._getPrefix(annotationNode.element.library);
       } else {
         throw unimplementedError(
             "This kind of metadata not yet supported: $annotationNode");
       }
       String arguments =
           annotationNode.arguments.arguments.map((Expression argument) {
-        return _extractConstantCode(argument, element.library, importCollector,
-            logger, dataId, resolver);
+        return _extractConstantCode(
+            argument, importCollector, logger, dataId, resolver);
       }).join(", ");
       if (_isPrivateName(name)) {
         logger.error("Cannot access private name $name");
       }
       metadataParts.add("const $prefix$name($arguments)");
     } else {
       // A field reference.
       if (_isPrivateName(annotationNode.name.name)) {
         logger.error("Cannot access private name ${annotationNode.name}");
       }
@@ skipping 316 matching lines @@
     }
   }
 
   @override
   int get nameLength => name.length;
 
   @override
   String get displayName => name;
 
   @override
+  String get documentationComment {

[sigurdm, 2016/03/07 08:53:08]

Are we using this?
Otherwise it might make sense to leave a throwing stub.

[eernst, 2016/03/07 14:50:34]

It guess it feels like a very brittle approach to make instances of a given
class throw as soon as you step outside a tiny "all we need is this" domain.
Because of that, I tend to think that all those methods are in need of fixing.
For instance, during the development of this CL I needed `MixinApplication.==`
for a while (all it takes is that you put a `MixinApplication` into a set).

But I guess that we can maintain an invariant that makes it feel more robust:
"No instance of `MixinApplication` will ever be referred by a variable (field,
parameter, etc.) declared in the analyzer".

If that is true then we have a guarantee that no methods will ever be invoked on
such an instance in the analyzer, and this means that we can define the "all we
need is this" domain based on method invocations on `Element` and subtypes in
reflectable itself. With that, stubbing aggressively would be safe and
well-understood (except that it is non-trivial to get a complete and correct
list of said methods).

Checking, it seems that we basically never call methods on analyzer objects, it
is all getters (an exception is `computeNode()`, but even that one does not take
arguments). So, presumably, we do actually maintain the invariant. (But it is
not trivial to check that it is satisfied, and it gets worse if we need to
repeat that check, in principle, for every change we make to reflectable).

With that, I think we can handle the aggressive throwing. Changed the method to
a throwing stub. ;-)

+    if (subclass != null) {
+      // This is a named mixin application (`class D = A with M`), so the
+      // documentation comment is the one associated with `subclass`
+      // (corresponding to `D` in the example).
+      return subclass.documentationComment;
+    }
+    // This is an anonymous mixin application, so there is no way a programmer
+    // could attach a documentation comment to it. However, adding a mixin `M`
+    // to a given superclass is conceptually similar to using `M` directly, so
+    // we return that documentation comment as the result. Note that `this`
+    // mixin application and the returned comment are in unrelated locations
+    // syntactically (e.g., they could be in different libraries), but it still
+    // seems like the most meaningful return value.
+    return mixin.documentationComment;
+  }
+
+  @override
   List<InterfaceType> get interfaces => <InterfaceType>[];
 
   @override
   List<ElementAnnotation> get metadata => <ElementAnnotation>[];
 
   @override
   bool get isSynthetic => declaredName == null;
 
   // The `InterfaceTypeImpl` may well call methods on this `MixinApplication`
   // whose body is unimplemented, but it still provides a slightly better
@@ skipping 35 matching lines @@
   bool get isEnum => false;
 
   @override
   List<TypeParameterElement> get typeParameters => <TypeParameterElement>[];
 
   @override
   NamedCompilationUnitMember computeNode() =>
       declaredName != null ? subclass.computeNode() : null;
 
   @override
+  ElementKind get kind => ElementKind.CLASS;
+
+  @override
+  ElementLocation get location => null;
+
+  @override
   bool operator ==(Object object) {
     return object is MixinApplication &&
         superclass == object.superclass &&
         mixin == object.mixin &&
         library == object.library &&
         subclass == object.subclass;
   }
 
   @override
   int get hashCode => superclass.hashCode ^ mixin.hashCode ^ library.hashCode;
@@ skipping 122 matching lines @@
   @override
   bool get isDeprecated => throw unreachableError("isDeprecated");
 
   @override
   bool get isOverride => throw unreachableError("isOverride");
 
   @override
   bool get isPublic => throw unreachableError("isPublic");
 
   @override
-  ElementKind get kind => throw unreachableError("kind");
-
-  @override
-  ElementLocation get location => throw unreachableError("location");
-
-  @override
   int get nameOffset => throw unreachableError("nameOffset");
 
   @override
   get source => throw unreachableError("source");
 
   @override
+  @deprecated
   get docRange => throw unreachableError("docRange");
 
   @override
   CompilationUnit get unit => throw unreachableError("unit");
 
   @override
   accept(ElementVisitor visitor) => throw unreachableError("accept");
 
   @override
+  @deprecated
   String computeDocumentationComment() =>
       throw unreachableError("computeDocumentationComment");
 
   @override
   Element getAncestor(predicate) => throw unreachableError("getAncestor");
 
   @override
   String getExtendedDisplayName(String shortName) =>
       throw unreachableError("getExtendedDisplayName");
 
@@ skipping 27 matching lines @@
 
 String _qualifiedTypeParameterName(TypeParameterElement typeParameterElement) {
   if (typeParameterElement == null) return "null";
   return "${_qualifiedName(typeParameterElement.enclosingElement)}."
       "${typeParameterElement.name}";
 }
 
 bool _isPrivateName(String name) {
   return name.startsWith("_") || name.contains("._");
 }
+
+/// Returns the `evaluationResult` for [annotation], after having forced
+/// constant resolution to take place in `annotation.compilationUnit.library`.
+/// Note that future invocations of `annotation.compilationUnit.library` will
+/// return a resolved library, but previously obtained results from that method
+/// will remain unresolved if they were unresolved when they were obtained.
+EvaluationResultImpl _annotationEvaluationResult(
+    ElementAnnotationImpl annotation) {
+  _resolvedLibraryOf(annotation.compilationUnit.library);
+  return annotation.evaluationResult;
+}
+
+/// Returns the `evaluationResult` for [constFieldElement], after having forced
+/// constant resolution to take place in `constFieldElement.library`.
+/// Note that future invocations of `constFieldElement.library` will
+/// return a resolved library, but previously obtained results from that method
+/// will remain unresolved if they were unresolved when they were obtained.
+EvaluationResultImpl _constFieldEvaluationResult(
+    ConstFieldElementImpl constFieldElement) {
+  // This is safe: The result returned from `library` will not be used again.
+  _resolvedLibraryOf(constFieldElement.library);
+  return constFieldElement.evaluationResult;
+}
+
+/// Returns the `evaluationResult` for [constTopLevelVariable], after having
+/// forced constant resolution to take place in `constTopLevelvariable.library`.
+/// Note that future invocations of `constTopLevelVariable.library` will
+/// return a resolved library, but previously obtained results from that method
+/// will remain unresolved if they were unresolved when they were obtained.
+EvaluationResultImpl _constTopLevelVariableEvaluationResult(
+    ConstTopLevelVariableElementImpl constTopLevelVariable) {
+  // This is safe: The result returned from `library` will not be used again.
+  _resolvedLibraryOf(constTopLevelVariable.library);
+  return constTopLevelVariable.evaluationResult;
+}
+
+/// Requests resolution of constants in [libraryElement] and returns a
+/// [LibraryElement] wherein they have been resolved. If the library has
+/// been obtained by evaluating `library` on an `Element` and all further
+/// usage of that library will happen by invoking `library` again then it is
+/// safe to ignore the returned value (because the future invocations of
+/// `library` will return the resolved library).
+LibraryElement _resolvedLibraryOf(LibraryElement libraryElement) {

[sigurdm, 2016/03/07 08:53:08]

would it be simpler to split this in two

void _ensureConstantResolution(LibraryElement libraryElement)
LibraryElement _resolvedLibraryOf(LibraryElement libraryElement)


It seems that's how it is used in practice.

[eernst, 2016/03/07 14:50:34]

The reason why I did not do that (I tried) is that I discovered that the given
library element does _not_ get resolved, which means that if you do
`_ensureConstantResolution(myLibrary)` at a call site then you must make sure
that `myLibrary` is immediately turned over to the garbage collector and then
you must fetch a fresh one (e.g., using `myLibrary = myElement.library` for some
suitable `myElement`). Otherwise you'll still get `null` when you try to get the
`evaluationResult` from a constant in that library.

Given that call sites must use the returned result and get rid of the old
library element, invocation of this method is unpleasantly non-standard, and
with that in mind I thought that it would be more maintainable to insist that a
result is being returned. After all, the usage `reflectableLibrary =
_resolvedLibrary(reflectableLibrary)` works, but a mere `var ignore =
_resolvedLibrary(reflectableLibrary)` does not.

The `_...EvaluationResult` methods are the exception where the returned result
is ignored, which works because the implementation of `evaluationResult` will
itself perform the lookup and get a fresh, resolved version of the library.

Adding a `void _ensureConstantResolution` method is asking for bugs.

+  LibraryElement resolvedLibrary = _resolvedLibraries[libraryElement];
+  if (resolvedLibrary == null) {
+    resolvedLibrary = libraryElement.context
+        .computeLibraryElement(libraryElement.definingCompilationUnit.source);
+    _resolvedLibraries[libraryElement] = resolvedLibrary;
+  }
+  return resolvedLibrary;
+}
+
+Map<LibraryElement, LibraryElement> _resolvedLibraries =
+    <LibraryElement, LibraryElement>{};