Fix several element properties in serialization.

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 283 matching lines @@
     if (members == null) return;
     members.forEachKey((String key) {
       Element member = members.getElement(key);
       if (member != null) {
         f(member);
       }
     });
   }
 }
 
-class AbstractFieldElementZ extends ElementZ implements AbstractFieldElement {
+class AbstractFieldElementZ extends ElementZ
+    with AbstractFieldElementCommon
+    implements AbstractFieldElement {
   final String name;
   final GetterElementZ getter;
   final SetterElementZ setter;
 
   AbstractFieldElementZ(this.name, this.getter, this.setter) {
     if (getter != null) {
       getter.abstractField = this;
       getter.setter = setter;
     }
     if (setter != null) {
@@ skipping 24 matching lines @@
   Element get enclosingElement => _canonicalElement.enclosingElement;
 
   @override
   int get sourceOffset => _canonicalElement.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => _canonicalElement.sourcePosition;
 
   @override
   ClassElement get enclosingClass => _canonicalElement.enclosingClass;
+
+  @override
+  bool get isClassMember => _canonicalElement.isClassMember;
+
+  @override
+  bool get isInstanceMember => _canonicalElement.isInstanceMember;
+
+  @override
+  bool get isStatic => _canonicalElement.isStatic;
+
+  @override
+  bool get isTopLevel => _canonicalElement.isTopLevel;
 }
 
 class LibraryElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, ContainerMixin, LibraryElementCommon
     implements LibraryElement {
   Uri _canonicalUri;
   CompilationUnitElement _entryCompilationUnit;
   Link<CompilationUnitElement> _compilationUnits;
   List<ImportElement> _imports;
   List<ExportElement> _exports;
@@ skipping 202 matching lines @@
   @override
   CompilationUnitElement get compilationUnit => this;
 
   @override
   Element get enclosingElement => library;
 
   @override
   SourceSpan get sourcePosition => new SourceSpan(script.resourceUri, 0, 0);
 
   @override
+  bool get isTopLevel => false;
+
+  @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
 
   @override
   void forEachLocalMember(f(Element element)) {
     if (_members == null) {
       _members = _decoder.getElements(Key.ELEMENTS, isOptional: true);
     }
     _members.forEach(f);
@@ skipping 81 matching lines @@
 
 abstract class InstanceMemberMixin implements DeserializedElementZ {
   @override
   bool get isTopLevel => false;
 
   @override
   bool get isStatic => false;
 
   @override
   bool get isInstanceMember => true;
+
+  @override
+  bool get isClassMember => true;
 }
 
 abstract class StaticMemberMixin implements DeserializedElementZ {
   @override
   bool get isTopLevel => false;
 
   @override
   bool get isStatic => true;
+
+  @override
+  bool get isClassMember => true;
 }
 
 abstract class TypedElementMixin implements DeserializedElementZ, TypedElement {
   DartType _type;
 
   @override
   DartType get type {
     if (_type == null) {
       _type = _decoder.getType(Key.TYPE);
     }
@@ skipping 263 matching lines @@
         ClassElementCommon,
         ClassElementMixin,
         class_members.ClassMemberMixin,
         TypeDeclarationMixin<InterfaceType>,
         AnalyzableElementMixin,
         AstElementMixinZ,
         MixinApplicationElementCommon,
         MixinApplicationElementMixin {
   final String name;
   final ClassElement _subclass;
-  final InterfaceType supertype;
-  final Link<DartType> interfaces;
+  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.supertype = supertype,
-        this.interfaces = const Link<DartType>().prepend(mixin),
+        this._supertypeBase = supertype,
+        this._mixinBase = mixin,
         this.name = "${supertype.name}+${mixin.name}";
 
   @override
   CompilationUnitElement get compilationUnit => _subclass.compilationUnit;
 
   @override
   bool get isTopLevel => true;
 
   @override
+  bool get isAbstract => true;
+
+  @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)) {
           ForwardingConstructorElementZ constructor =
@@ skipping 25 matching lines @@
       TypeVariableType typeVariable = typeVariables[type.element.index];
       SyntheticTypeVariableElementZ typeVariableElement = typeVariable.element;
       typeVariableElement._type = typeVariable;
       typeVariableElement._bound =
           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);
+    }
+    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));
+    }
+    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);
     }
@@ skipping 249 matching lines @@
     return enclosingClass.thisType.substByContext(newType);
   }
 
   @override
   DartType computeType(Resolution resolution) => type;
 
   @override
   bool get isConst => false;
 
   @override
+  bool get isClassMember => true;
+
+  @override
   ConstantConstructor get constantConstructor => null;
 
   @override
   bool get hasEffectiveTarget => true;
 
   @override
   ConstructorElement get effectiveTarget => this;
 
   @override
   Element get enclosingElement => enclosingClass;
@@ skipping 180 matching lines @@
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 
   @override
   AsyncMarker get asyncMarker {
     return _decoder.getEnum(Key.ASYNC_MARKER, AsyncMarker.values);
   }
 
   @override
+  bool get isAbstract => _decoder.getBool(Key.IS_ABSTRACT);
+
+  @override
   bool get isOperator => _decoder.getBool(Key.IS_OPERATOR);
 }
 
 class TopLevelFunctionElementZ extends FunctionElementZ
     with LibraryMemberMixin {
   TopLevelFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticFunctionElementZ extends FunctionElementZ
     with ClassMemberMixin, StaticMemberMixin {
@@ skipping 81 matching lines @@
 
   @override
   ElementKind get kind => ElementKind.GETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitGetterElement(this, arg);
   }
 
   @override
+  bool get isAbstract => _decoder.getBool(Key.IS_ABSTRACT);
+
+  @override
   AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 }
 
 class TopLevelGetterElementZ extends GetterElementZ with LibraryMemberMixin {
   TopLevelGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticGetterElementZ extends GetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticGetterElementZ(ObjectDecoder decoder) : super(decoder);
@@ skipping 20 matching lines @@
 
   @override
   ElementKind get kind => ElementKind.SETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitSetterElement(this, arg);
   }
 
   @override
+  bool get isAbstract => _decoder.getBool(Key.IS_ABSTRACT);
+
+  @override
   AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 }
 
 class TopLevelSetterElementZ extends SetterElementZ with LibraryMemberMixin {
   TopLevelSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticSetterElementZ extends SetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticSetterElementZ(ObjectDecoder decoder) : super(decoder);
@@ skipping 513 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }