Improve equivalence testing of 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;
@@ skipping 953 matching lines @@
 
 class NamedMixinApplicationElementZ extends ClassElementZ
     with MixinApplicationElementMixin {
   Link<Element> _constructors;
   InterfaceType _mixinType;
 
   NamedMixinApplicationElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   InterfaceType get mixinType => _mixinType ??= _decoder.getType(Key.MIXIN);
+
+  @override
+  ClassElement get subclass => null;
 }
 
 class UnnamedMixinApplicationElementZ extends ElementZ
     with
         ClassElementCommon,
         ClassElementMixin,
         class_members.ClassMemberMixin,
         TypeDeclarationMixin<InterfaceType>,
         AnalyzableElementMixin,
         AstElementMixinZ,
         MixinApplicationElementCommon,
         MixinApplicationElementMixin {
   final String name;
-  final ClassElement _subclass;
+  final ClassElement subclass;
   final InterfaceType _supertypeBase;
   final InterfaceType _mixinBase;
   InterfaceType _supertype;
   Link<DartType> _interfaces;
   OrderedTypeSet _allSupertypesAndSelf;
   Link<ConstructorElement> _constructors;
 
   UnnamedMixinApplicationElementZ(
-      ClassElement subclass, InterfaceType supertype, InterfaceType mixin)
-      : this._subclass = subclass,
-        this._supertypeBase = supertype,
+      this.subclass, InterfaceType supertype, InterfaceType mixin)
+      : this._supertypeBase = supertype,
         this._mixinBase = mixin,
         this.name = "${supertype.name}+${mixin.name}";
 
   @override
-  CompilationUnitElement get compilationUnit => _subclass.compilationUnit;
+  CompilationUnitElement get compilationUnit => subclass.compilationUnit;
 
   @override
   bool get isTopLevel => true;
 
   @override
   bool get isAbstract => true;
 
   @override
   bool get isUnnamedMixinApplication => true;
 
@@ skipping 14 matching lines @@
       _constructors = builder.toLink();
     }
     return _constructors;
   }
 
   @override
   List<DartType> _getTypeVariables() {
     // Create synthetic type variables for the mixin application.
     List<DartType> typeVariables = <DartType>[];
     int index = 0;
-    for (TypeVariableType type in _subclass.typeVariables) {
+    for (TypeVariableType type in subclass.typeVariables) {
       SyntheticTypeVariableElementZ typeVariableElement =
           new SyntheticTypeVariableElementZ(this, index, type.name);
       TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
       typeVariables.add(typeVariable);
       index++;
     }
     // Setup bounds on the synthetic type variables.
-    for (TypeVariableType type in _subclass.typeVariables) {
+    for (TypeVariableType type in subclass.typeVariables) {
       TypeVariableType typeVariable = typeVariables[type.element.index];
       SyntheticTypeVariableElementZ typeVariableElement = typeVariable.element;
       typeVariableElement._type = typeVariable;
       typeVariableElement._bound =
-          type.element.bound.subst(typeVariables, _subclass.typeVariables);
+          type.element.bound.subst(typeVariables, subclass.typeVariables);
     }
     return typeVariables;
   }
 
   @override
   InterfaceType get supertype {
     if (_supertype == null) {
       // Substitute the type variables in [_supertypeBase] provided by
       // [_subclass] with the type variables in this unnamed mixin application.
       //
       // For instance
       //    class S<S.T> {}
       //    class M<M.T> {}
       //    class C<C.T> extends S<C.T> with M<C.T> {}
       // the unnamed mixin application should be
       //    abstract class S+M<S+M.T> extends S<S+M.T> implements M<S+M.T> {}
       // but the supertype is provided as S<C.T> and we need to substitute S+M.T
       // for C.T.
-      _supertype = _supertypeBase.subst(typeVariables, _subclass.typeVariables);
+      _supertype = _supertypeBase.subst(typeVariables, subclass.typeVariables);
     }
     return _supertype;
   }
 
   @override
   Link<DartType> get interfaces {
     if (_interfaces == null) {
       // Substitute the type variables in [_mixinBase] provided by
       // [_subclass] with the type variables in this unnamed mixin application.
       //
       // For instance
       //    class S<S.T> {}
       //    class M<M.T> {}
       //    class C<C.T> extends S<C.T> with M<C.T> {}
       // the unnamed mixin application should be
       //    abstract class S+M<S+M.T> extends S<S+M.T> implements M<S+M.T> {}
       // but the mixin is provided as M<C.T> and we need to substitute S+M.T
       // for C.T.
       _interfaces = const Link<DartType>()
-          .prepend(_mixinBase.subst(typeVariables, _subclass.typeVariables));
+          .prepend(_mixinBase.subst(typeVariables, subclass.typeVariables));
     }
     return _interfaces;
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMixinApplicationElement(this, arg);
   }
 
   @override
   OrderedTypeSet get allSupertypesAndSelf {
     if (_allSupertypesAndSelf == null) {
       _allSupertypesAndSelf = new OrderedTypeSetBuilder(this)
           .createOrderedTypeSet(supertype, interfaces);
     }
     return _allSupertypesAndSelf;
   }
 
   @override
-  Element get enclosingElement => _subclass.enclosingElement;
+  Element get enclosingElement => subclass.enclosingElement;
 
   @override
   bool get isObject => false;
 
   @override
   bool get isProxy => false;
 
   @override
   LibraryElement get library => enclosingElement.library;
 
   @override
   InterfaceType get mixinType => interfaces.head;
 
   @override
-  int get sourceOffset => _subclass.sourceOffset;
+  int get sourceOffset => subclass.sourceOffset;
 
   @override
-  SourceSpan get sourcePosition => _subclass.sourcePosition;
+  SourceSpan get sourcePosition => subclass.sourcePosition;
 }
 
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
 
   EnumClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isEnumClass => true;
 
@@ skipping 1102 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }