Handle resolvedAst for forwarding constructors and callType on unnamed mixin applications.

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
 
 import '../common.dart';
+import '../common/names.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/common.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show FunctionSignatureX;
 import '../elements/visitor.dart';
 import '../io/source_file.dart';
 import '../ordered_typeset.dart';
@@ skipping 742 matching lines @@
   @override
   bool get isExternal {
     return _decoder.getBool(Key.IS_EXTERNAL,
         isOptional: true, defaultValue: false);
   }
 
   @override
   List<DartType> get typeVariables => functionSignature.typeVariables;
 }
 
-abstract class ClassElementMixin implements ElementZ, ClassElement {
+abstract class ClassElementMixin
+    implements ElementZ, ClassElement, class_members.ClassMemberMixin {
+  bool _isResolved = false;
+
   InterfaceType _createType(List<DartType> typeArguments) {
     return new InterfaceType(this, typeArguments);
   }
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
   bool get hasConstructor => _unsupported('hasConstructor');
 
@@ skipping 13 matching lines @@
       return constructor;
     }
     return null;
   }
 
   @override
   ClassElement get superclass => supertype != null ? supertype.element : null;
 
   @override
   void ensureResolved(Resolution resolution) {
-    resolution.registerClass(this);
+    if (!_isResolved) {
+      _isResolved = true;
+      class_members.MembersCreator
+          .computeClassMembersByName(resolution, this, Identifiers.call);
+      resolution.registerClass(this);
+    }
   }
 }
 
 class ClassElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixinZ,
         ClassElementCommon,
         class_members.ClassMemberMixin,
         ContainerMixin,
@@ skipping 76 matching lines @@
 
   @override
   bool get isProxy => _decoder.getBool(Key.IS_PROXY);
 
   @override
   bool get isUnnamedMixinApplication => false;
 
   @override
   FunctionType get callType {
     _ensureSuperHierarchy();
+    // TODO(johnniwinther): Why can't this always be computed in ensureResolved?
     return _callType;
   }
 }
 
 abstract class MixinApplicationElementMixin
     implements ElementZ, MixinApplicationElement {
   @override
   bool get isMixinApplication => true;
 
   @override
@@ skipping 44 matching lines @@
   @override
   bool get isUnnamedMixinApplication => true;
 
   Link<ConstructorElement> get constructors {
     if (_constructors == null) {
       LinkBuilder<ConstructorElement> builder =
           new LinkBuilder<ConstructorElement>();
       for (ConstructorElement definingConstructor in superclass.constructors) {
         if (definingConstructor.isGenerativeConstructor &&
             definingConstructor.memberName.isAccessibleFrom(library)) {
-          builder.addLast(
-              new ForwardingConstructorElementZ(this, definingConstructor));
+          ForwardingConstructorElementZ constructor =
+              new ForwardingConstructorElementZ(this, definingConstructor);
+          constructor.resolvedAst = new SynthesizedResolvedAst(
+              constructor, ResolvedAstKind.FORWARDING_CONSTRUCTOR);
+          builder.addLast(constructor);
         }
       }
       _constructors = builder.toLink();
     }
     return _constructors;
   }
 
   @override
   List<DartType> _getTypeVariables() {
     // Create synthetic type variables for the mixin application.
@@ skipping 1154 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }