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

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

 // Copyright (c) 2012, 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.compute_members;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         LibraryElement,
         Member,
         MemberElement,
         MemberSignature,
         MixinApplicationElement,
         Name;
 import '../util/util.dart';
 
 part 'member_impl.dart';
 
 abstract class MembersCreator {
   final ClassElement cls;
-  final Compiler compiler;
+  final Resolution resolution;
 
   final Iterable<String> computedMemberNames;
   final Map<Name, Member> classMembers;
 
   Map<dynamic /* Member | Element */, Set<MessageKind>> reportedMessages =
       new Map<dynamic, Set<MessageKind>>();
 
   MembersCreator(
-      Compiler this.compiler,
-      ClassElement this.cls,
-      Iterable<String> this.computedMemberNames,
-      Map<Name, Member> this.classMembers) {
+      this.resolution, this.cls, this.computedMemberNames, this.classMembers) {
     assert(invariant(cls, cls.isDeclaration,
         message: "Members may only be computed on declarations."));
   }
 
-  DiagnosticReporter get reporter => compiler.reporter;
-
-  Resolution get resolution => compiler.resolution;
+  DiagnosticReporter get reporter => resolution.reporter;
 
   void reportMessage(var marker, MessageKind kind, report()) {
     Set<MessageKind> messages =
         reportedMessages.putIfAbsent(marker, () => new Set<MessageKind>());
     if (messages.add(kind)) {
       report();
     }
   }
 
   bool shouldSkipMember(MemberSignature member) {
@@ skipping 53 matching lines @@
     // Inherit class and interface members from superclass.
     void inheritClassMember(DeclaredMember member) {
       if (shouldSkipMember(member)) return;
       if (!member.isStatic) {
         DeclaredMember inherited = member.inheritFrom(supertype);
         classMembers[member.name] = inherited;
       }
     }
 
     if (names != null) {
-      _computeClassMember(compiler, superclass, name, names);
+      _computeClassMember(resolution, superclass, name, names);
       for (Name memberName in names) {
         inheritClassMember(superclass.lookupClassMember(memberName));
       }
     } else {
-      computeAllClassMembers(compiler, superclass);
+      computeAllClassMembers(resolution, superclass);
       superclass.forEachClassMember(inheritClassMember);
     }
   }
 
   /// Compute the members declared or directly mixed in [cls].
   ///
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   Map<Name, Member> computeClassMembers(String nameText, Setlet<Name> names) {
     Map<Name, Member> declaredMembers = new Map<Name, Member>();
@@ skipping 11 matching lines @@
             DeclaredMember mixedInMember =
                 member.inheritFrom(mixinApplication.mixinType);
             DeclaredMember inherited = classMembers[name];
             classMembers[name] = mixedInMember;
             checkValidOverride(mixedInMember, inherited);
           }
         }
 
         if (names != null) {
           _computeClassMember(
-              compiler, mixinApplication.mixin, nameText, names);
+              resolution, mixinApplication.mixin, nameText, names);
           for (Name memberName in names) {
             inheritMixinMember(
                 mixinApplication.mixin.lookupClassMember(memberName));
           }
         } else {
-          computeAllClassMembers(compiler, mixinApplication.mixin);
+          computeAllClassMembers(resolution, mixinApplication.mixin);
           mixinApplication.mixin.forEachClassMember(inheritMixinMember);
         }
       }
     } else {
       LibraryElement library = cls.library;
       InterfaceType thisType = cls.thisType;
 
       void createMember(MemberElement element) {
         if (element.isConstructor) return;
         String elementName = element.name;
@@ skipping 132 matching lines @@
     }
     // TODO(johnniwinther): If [cls] is not abstract, check that for all
     // interface members, there is a class member whose type is a subtype of
     // the interface member.
   }
 
   /// Checks that [cls], if it implements Function, has defined call().
   void checkImplementsFunctionWithCall() {
     assert(!cls.isAbstract);
 
-    ClassElement functionClass = compiler.coreClasses.functionClass;
+    ClassElement functionClass = resolution.coreClasses.functionClass;
     if (cls.asInstanceOf(functionClass) == null) return;
     if (cls.lookupMember(Identifiers.call) != null) return;
     // TODO(johnniwinther): Make separate methods for backend exceptions.
     // Avoid warnings on backend implementation classes for closures.
-    if (compiler.backend.isBackendLibrary(cls.library)) return;
+    if (resolution.target.isTargetSpecificLibrary(cls.library)) return;
 
     reportMessage(functionClass, MessageKind.UNIMPLEMENTED_METHOD, () {
       reporter.reportWarningMessage(cls, MessageKind.UNIMPLEMENTED_METHOD_ONE, {
         'class': cls.name,
         'name': Identifiers.call,
         'method': Identifiers.call,
         'declarer': functionClass.name
       });
     });
   }
@@ skipping 28 matching lines @@
           superclass = superclass.superclass;
         }
       }
     } else {
       assert(declared.name == superMember.name);
 
       if (declared.isStatic) {
         for (Member inherited in superMember.declarations) {
           if (cls == inherited.declarer.element) {
             // An error should already have been reported.
-            assert(invariant(declared.element, compiler.compilationFailed));
+            assert(invariant(
+                declared.element, resolution.reporter.hasReportedError));
             continue;
           }
 
           reportMessage(inherited.element, MessageKind.NO_STATIC_OVERRIDE, () {
             reportErrorWithContext(
                 declared.element,
                 MessageKind.NO_STATIC_OVERRIDE,
                 inherited.element,
                 MessageKind.NO_STATIC_OVERRIDE_CONT);
           });
         }
       }
 
       DartType declaredType = declared.functionType;
       for (Member inherited in superMember.declarations) {
         if (inherited.element == declared.element) {
           // TODO(ahe): For some reason, "call" elements are repeated in
           // superMember.declarations. Investigate why.
         } else if (cls == inherited.declarer.element) {
           // An error should already have been reported.
-          assert(invariant(declared.element, compiler.compilationFailed,
-              message: "Member $inherited inherited from its "
-                  "declaring class: ${cls}."));
+          assert(
+              invariant(declared.element, resolution.reporter.hasReportedError,
+                  message: "Member $inherited inherited from its "
+                      "declaring class: ${cls}."));
           continue;
         }
 
         void reportError(MessageKind errorKind, MessageKind infoKind) {
           reportMessage(inherited.element, MessageKind.INVALID_OVERRIDE_METHOD,
               () {
             reporter.reportError(
                 reporter.createMessage(declared.element, errorKind, {
                   'name': declared.name.text,
                   'class': cls.thisType,
@@ skipping 15 matching lines @@
           reportError(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
               MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
         } else if (declared.isGetter && inherited.isMethod) {
           reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER,
               MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT);
         } else if (declared.isMethod && inherited.isGetter) {
           reportError(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD,
               MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT);
         } else {
           DartType inheritedType = inherited.functionType;
-          if (!compiler.types.isSubtype(declaredType, inheritedType)) {
+          if (!resolution.types.isSubtype(declaredType, inheritedType)) {
             void reportWarning(
                 var marker, MessageKind warningKind, MessageKind infoKind) {
               reportMessage(marker, MessageKind.INVALID_OVERRIDE_METHOD, () {
                 reporter.reportWarning(
                     reporter.createMessage(declared.element, warningKind, {
                       'declaredType': declared.type,
                       'name': declared.name.text,
                       'class': cls.thisType,
                       'inheritedType': inherited.type,
                       'inheritedClass': inherited.declarer
@@ skipping 63 matching lines @@
           'memberName': contextElement.name,
           'className': contextElement.enclosingClass.name
         }),
         <DiagnosticMessage>[
           reporter.createMessage(contextElement, contextMessage),
         ]);
   }
 
   /// Compute all class and interface names by the [name] in [cls].
   static void computeClassMembersByName(
-      Compiler compiler, ClassMemberMixin cls, String name) {
+      Resolution resolution, ClassMemberMixin cls, String name) {
     if (cls.isMemberComputed(name)) return;
     LibraryElement library = cls.library;
     _computeClassMember(
-        compiler,
+        resolution,
         cls,
         name,
         new Setlet<Name>()
           ..add(new Name(name, library))
           ..add(new Name(name, library, isSetter: true)));
   }
 
-  static void _computeClassMember(Compiler compiler, ClassMemberMixin cls,
+  static void _computeClassMember(Resolution resolution, ClassMemberMixin cls,
       String name, Setlet<Name> names) {
-    cls.computeClassMember(compiler, name, names);
+    cls.computeClassMember(resolution, name, names);
   }
 
   /// Compute all class and interface names in [cls].
-  static void computeAllClassMembers(Compiler compiler, ClassMemberMixin cls) {
-    cls.computeAllClassMembers(compiler);
+  static void computeAllClassMembers(
+      Resolution resolution, ClassMemberMixin cls) {
+    cls.computeAllClassMembers(resolution);
   }
 }
 
 /// Class member creator for classes where the interface members are known to
 /// be a subset of the class members.
 class ClassMembersCreator extends MembersCreator {
-  ClassMembersCreator(Compiler compiler, ClassElement cls,
+  ClassMembersCreator(Resolution resolution, ClassElement cls,
       Iterable<String> computedMemberNames, Map<Name, Member> classMembers)
-      : super(compiler, cls, computedMemberNames, classMembers);
+      : super(resolution, cls, computedMemberNames, classMembers);
 
   Map<Name, Member> computeMembers(String name, Setlet<Name> names) {
     computeSuperMembers(name, names);
     return computeClassMembers(name, names);
   }
 
   void computeSuperMembers(String name, Setlet<Name> names) {
     computeSuperClassMembers(name, names);
   }
 
   void checkInterfaceImplementation() {
     LibraryElement library = cls.library;
     classMembers.forEach((Name name, Member classMember) {
       if (!name.isAccessibleFrom(library)) return;
       checkInterfaceMember(name, classMember, classMember.implementation);
     });
   }
 }
 
 /// Class Member creator for classes where the interface members might be
 /// different from the class members.
 class InterfaceMembersCreator extends MembersCreator {
   final Map<Name, MemberSignature> interfaceMembers;
 
   InterfaceMembersCreator(
-      Compiler compiler,
+      Resolution resolution,
       ClassElement cls,
       Iterable<String> computedMemberNames,
       Map<Name, Member> classMembers,
       Map<Name, MemberSignature> this.interfaceMembers)
-      : super(compiler, cls, computedMemberNames, classMembers);
+      : super(resolution, cls, computedMemberNames, classMembers);
 
   Map<Name, Member> computeMembers(String name, Setlet<Name> names) {
     Map<Name, Setlet<Member>> inheritedInterfaceMembers =
         computeSuperMembers(name, names);
     Map<Name, Member> declaredMembers = computeClassMembers(name, names);
     computeInterfaceMembers(inheritedInterfaceMembers, declaredMembers);
     return declaredMembers;
   }
 
   /// Compute the members of the super type(s) of [cls]. The class members are
@@ skipping 43 matching lines @@
       inheritInterfaceMembers(supertype);
     }
 
     // Inherit interface members from superinterfaces.
     for (Link<DartType> link = cls.interfaces;
         !link.isEmpty;
         link = link.tail) {
       InterfaceType superinterface = link.head;
       if (names != null) {
         MembersCreator._computeClassMember(
-            compiler, superinterface.element, name, names);
+            resolution, superinterface.element, name, names);
         for (Name memberName in names) {
           inheritInterfaceMember(superinterface,
               superinterface.element.lookupInterfaceMember(memberName));
         }
       } else {
-        MembersCreator.computeAllClassMembers(compiler, superinterface.element);
+        MembersCreator.computeAllClassMembers(
+            resolution, superinterface.element);
         inheritInterfaceMembers(superinterface);
       }
     }
 
     return inheritedInterfaceMembers;
   }
 
   /// Checks that a class member exists for every interface member.
   void checkInterfaceImplementation() {
     LibraryElement library = cls.library;
@@ skipping 36 matching lines @@
             new Map<DartType, Setlet<Member>>();
         outer: for (Member inherited in inheritedMembers) {
           if (inherited.isGetter) {
             someAreGetters = true;
             if (!allAreGetters) break outer;
           } else {
             allAreGetters = false;
             if (someAreGetters) break outer;
           }
           for (MemberSignature other in inheritedMembers) {
-            if (!compiler.types
+            if (!resolution.types
                 .isSubtype(inherited.functionType, other.functionType)) {
               continue outer;
             }
           }
           subtypesOfAllInherited
               .putIfAbsent(inherited.functionType, () => new Setlet<Member>())
               .add(inherited);
         }
         if (someAreGetters && !allAreGetters) {
           DiagnosticMessage warning = reporter.createMessage(
@@ skipping 115 matching lines @@
   Iterable<String> computedMemberNames;
 
   /// If `true` interface members are the non-static class member.
   bool interfaceMembersAreClassMembers = true;
 
   Map<Name, Member> classMembers;
   Map<Name, MemberSignature> interfaceMembers;
 
   /// Creates the necessary maps and [MembersCreator] for compute members of
   /// this class.
-  MembersCreator _prepareCreator(Compiler compiler) {
+  MembersCreator _prepareCreator(Resolution resolution) {
     if (classMembers == null) {
-      ensureResolved(compiler.resolution);
+      ensureResolved(resolution);
       classMembers = new Map<Name, Member>();
 
       if (interfaceMembersAreClassMembers) {
         ClassMemberMixin superclass = this.superclass;
         if ((superclass != null &&
                 (!superclass.interfaceMembersAreClassMembers ||
                     superclass.isMixinApplication)) ||
             !interfaces.isEmpty) {
           interfaceMembersAreClassMembers = false;
         }
       }
       if (!interfaceMembersAreClassMembers) {
         interfaceMembers = new Map<Name, MemberSignature>();
       }
     }
     return interfaceMembersAreClassMembers
         ? new ClassMembersCreator(
-            compiler, this, computedMemberNames, classMembers)
-        : new InterfaceMembersCreator(compiler, this, computedMemberNames,
+            resolution, this, computedMemberNames, classMembers)
+        : new InterfaceMembersCreator(resolution, this, computedMemberNames,
             classMembers, interfaceMembers);
   }
 
   static Iterable<String> _EMPTY_MEMBERS_NAMES = const <String>[];
 
   /// Compute the members by the name [name] for this class. [names] collects
   /// the set of possible variations of [name], including getter, setter and
   /// and private names.
-  void computeClassMember(Compiler compiler, String name, Setlet<Name> names) {
+  void computeClassMember(
+      Resolution resolution, String name, Setlet<Name> names) {
     if (isMemberComputed(name)) return;
     if (Name.isPrivateName(name)) {
       names
         ..add(new Name(name, library))
         ..add(new Name(name, library, isSetter: true));
     }
-    MembersCreator creator = _prepareCreator(compiler);
+    MembersCreator creator = _prepareCreator(resolution);
     creator.computeMembersByName(name, names);
     if (computedMemberNames == null) {
       computedMemberNames = _EMPTY_MEMBERS_NAMES;
     }
     if (name != Identifiers.call) {
       Setlet<String> set;
       if (identical(computedMemberNames, _EMPTY_MEMBERS_NAMES)) {
         computedMemberNames = set = new Setlet<String>();
       } else {
         set = computedMemberNames;
       }
       set.add(name);
     }
   }
 
-  void computeAllClassMembers(Compiler compiler) {
+  void computeAllClassMembers(Resolution resolution) {
     if (areAllMembersComputed()) return;
-    MembersCreator creator = _prepareCreator(compiler);
+    MembersCreator creator = _prepareCreator(resolution);
     creator.computeAllMembers();
     computedMemberNames = null;
     assert(invariant(this, areAllMembersComputed()));
   }
 
   bool areAllMembersComputed() {
     return computedMemberNames == null && classMembers != null;
   }
 
   bool isMemberComputed(String name) {
@@ skipping 32 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }