Ensure metadata on imports/exports is resolved for serialization.

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart'
     show
@@ skipping 463 matching lines @@
 class ConstructorResolver extends CommonResolverVisitor<ConstructorResult> {
   final ResolverVisitor resolver;
   final bool inConstContext;
 
   ConstructorResolver(Resolution resolution, this.resolver,
       {bool this.inConstContext: false})
       : super(resolution);
 
   ResolutionRegistry get registry => resolver.registry;
 
+  Element get context => resolver.enclosingElement;
+
   visitNode(Node node) {
     throw 'not supported';
   }
 
   ConstructorResult reportAndCreateErroneousConstructorElement(
       Spannable diagnosticNode,
       ConstructorResultKind resultKind,
       DartType type,
-      Element enclosing,
       String name,
       MessageKind kind,
       Map arguments,
       {bool isError: false,
       bool missingConstructor: false,
       List<DiagnosticMessage> infos: const <DiagnosticMessage>[]}) {
     if (missingConstructor) {
       registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     } else {
       registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
     }
     DiagnosticMessage message =
         reporter.createMessage(diagnosticNode, kind, arguments);
     if (isError || inConstContext) {
       reporter.reportError(message, infos);
     } else {
       reporter.reportWarning(message, infos);
     }
     ErroneousElement error =
-        new ErroneousConstructorElementX(kind, arguments, name, enclosing);
+        new ErroneousConstructorElementX(kind, arguments, name, context);
     if (type == null) {
       type = new MalformedType(error, null);
     }
     return new ConstructorResult.forError(resultKind, error, type);
   }
 
   ConstructorResult resolveConstructor(PrefixElement prefix, InterfaceType type,
       Node diagnosticNode, String constructorName) {
     ClassElement cls = type.element;
     cls.ensureResolved(resolution);
     ConstructorElement constructor = findConstructor(
-        resolver.enclosingElement.library, cls, constructorName);
+        context.library, cls, constructorName);
     if (constructor == null) {
       MessageKind kind = constructorName.isEmpty
           ? MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR
           : MessageKind.CANNOT_FIND_CONSTRUCTOR;
       return reportAndCreateErroneousConstructorElement(
           diagnosticNode,
           ConstructorResultKind.UNRESOLVED_CONSTRUCTOR,
           type,
-          cls,
           constructorName,
           kind,
           {'className': cls.name, 'constructorName': constructorName},
           missingConstructor: true);
     } else if (inConstContext && !constructor.isConst) {
       reporter.reportErrorMessage(
           diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
       return new ConstructorResult(
           ConstructorResultKind.NON_CONSTANT, prefix, constructor, type);
     } else {
       if (cls.isEnumClass && resolver.currentClass != cls) {
         return reportAndCreateErroneousConstructorElement(
             diagnosticNode,
             ConstructorResultKind.INVALID_TYPE,
             type,
-            cls,
             constructorName,
             MessageKind.CANNOT_INSTANTIATE_ENUM,
             {'enumName': cls.name},
             isError: true);
       }
       if (constructor.isGenerativeConstructor) {
         if (cls.isAbstract) {
           reporter.reportWarningMessage(
               diagnosticNode, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
           registry.registerFeature(Feature.ABSTRACT_CLASS_INSTANTIATION);
@@ skipping 40 matching lines @@
           resolveConstructor(result.prefix, result.type, diagnosticNode, '');
     } else {
       Element element = result.element;
       if (element.isMalformed) {
         result = constructorResultForErroneous(diagnosticNode, element);
       } else {
         result = reportAndCreateErroneousConstructorElement(
             diagnosticNode,
             ConstructorResultKind.INVALID_TYPE,
             null,
-            element,
             element.name,
             MessageKind.NOT_A_TYPE,
             {'node': diagnosticNode});
       }
     }
     resolver.registry.setType(expression, result.type);
     return result;
   }
 
   ConstructorResult visitTypeAnnotation(TypeAnnotation node) {
@@ skipping 33 matching lines @@
     if (receiver.type != null) {
       if (receiver.type.isInterfaceType) {
         return resolveConstructor(
             receiver.prefix, receiver.type, name, name.source);
       } else {
         // TODO(johnniwinther): Update the message for the different types.
         return reportAndCreateErroneousConstructorElement(
             name,
             ConstructorResultKind.INVALID_TYPE,
             null,
-            resolver.enclosingElement,
             name.source,
             MessageKind.NOT_A_TYPE,
             {'node': name});
       }
     } else if (receiver.element.isPrefix) {
       PrefixElement prefix = receiver.element;
       Element member = prefix.lookupLocalMember(name.source);
       return constructorResultForElement(node, name.source, member,
           prefix: prefix);
     } else {
@@ skipping 18 matching lines @@
 
   ConstructorResult constructorResultForElement(
       Node node, String name, Element element,
       {PrefixElement prefix}) {
     element = Elements.unwrap(element, reporter, node);
     if (element == null) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           null,
-          resolver.enclosingElement,
           name,
           MessageKind.CANNOT_RESOLVE,
           {'name': name});
     } else if (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           null,
-          resolver.enclosingElement,
           name,
           ambiguous.messageKind,
           ambiguous.messageArguments,
-          infos: ambiguous.computeInfos(resolver.enclosingElement, reporter));
+          infos: ambiguous.computeInfos(context, reporter));
     } else if (element.isMalformed) {
       return constructorResultForErroneous(node, element);
     } else if (element.isClass) {
       ClassElement cls = element;
       cls.computeType(resolution);
       return constructorResultForType(node, cls.rawType, prefix: prefix);
     } else if (element.isPrefix) {
       return new ConstructorResult.forPrefix(element);
     } else if (element.isTypedef) {
       TypedefElement typdef = element;
       typdef.ensureResolved(resolution);
       return constructorResultForType(node, typdef.rawType);
     } else if (element.isTypeVariable) {
       TypeVariableElement typeVariableElement = element;
       return constructorResultForType(node, typeVariableElement.type);
     } else {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           null,
-          resolver.enclosingElement,
           name,
           MessageKind.NOT_A_TYPE,
           {'node': name});
     }
   }
 
   ConstructorResult constructorResultForErroneous(Node node, Element error) {
     if (error is! ErroneousElementX) {
       // Parser error. The error has already been reported.
       error = new ErroneousConstructorElementX(
           MessageKind.NOT_A_TYPE, {'node': node}, error.name, error);
       registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
     }
     return new ConstructorResult.forError(ConstructorResultKind.INVALID_TYPE,
         error, new MalformedType(error, null));
   }
 
   ConstructorResult constructorResultForType(Node node, DartType type,
       {PrefixElement prefix}) {
     String name = type.name;
     if (type.isTypeVariable) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           type,
-          resolver.enclosingElement,
           name,
           MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
           {'typeVariableName': name});
     } else if (type.isMalformed) {
       // `type is MalformedType`: `MethodTypeVariableType` is handled above.
       return new ConstructorResult.forError(
           ConstructorResultKind.INVALID_TYPE, type.element, type);
     } else if (type.isInterfaceType) {
       return new ConstructorResult.forType(prefix, type);
     } else if (type.isTypedef) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           type,
-          resolver.enclosingElement,
           name,
           MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
           {'typedefName': name});
     }
     return reporter.internalError(node, "Unexpected constructor type $type");
   }
 }
 
 /// The kind of constructor found by the [ConstructorResolver].
 enum ConstructorResultKind {
@@ skipping 97 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }