Support per-library 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 57 matching lines @@
     return null;
   }
 
   @override
   FunctionElement asFunctionElement() => null;
 
   @override
   Scope buildScope() => _unsupported('analyzableElement');
 
   @override
-  CompilationUnitElement get compilationUnit {
-    return _unsupported('compilationUnit');
-  }
-
-  @override
   ClassElement get enclosingClass => null;
 
   @override
   Element get enclosingClassOrCompilationUnit {
     return _unsupported('enclosingClassOrCompilationUnit');
   }
 
   @override
   LibraryElement get implementationLibrary => library;
 
@@ skipping 233 matching lines @@
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAbstractFieldElement(this, arg);
   }
 
   @override
   LibraryElement get library => _canonicalElement.library;
 
   @override
+  CompilationUnitElement get compilationUnit {
+    return _canonicalElement.compilationUnit;
+  }
+
+  @override
   Element get enclosingElement => _canonicalElement.enclosingElement;
 
   @override
   SourceSpan get sourcePosition => _canonicalElement.sourcePosition;
 
   @override
   ClassElement get enclosingClass => _canonicalElement.enclosingClass;
 }
 
 class LibraryElementZ extends DeserializedElementZ
@@ skipping 23 matching lines @@
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLibraryElement(this, arg);
   }
 
   @override
   LibraryElement get library => this;
 
   @override
+  CompilationUnitElement get compilationUnit => entryCompilationUnit;
+
+  @override
   Uri get canonicalUri {
     if (_canonicalUri == null) {
       _canonicalUri = _decoder.getUri(Key.CANONICAL_URI);
     }
     return _canonicalUri;
   }
 
   @override
   CompilationUnitElement get entryCompilationUnit {
     if (_entryCompilationUnit == null) {
@@ skipping 338 matching lines @@
   @override
   FunctionElement asFunctionElement() => this;
 
   @override
   bool get isExternal {
     return _decoder.getBool(
         Key.IS_EXTERNAL, isOptional: true, defaultValue: false);
   }
 }
 
+abstract class ClassElementMixin implements ElementZ, ClassElement {
+
+  InterfaceType _createType(List<DartType> typeArguments) {
+    return new InterfaceType(this, typeArguments);
+  }
+
+  @override
+  ElementKind get kind => ElementKind.CLASS;
+
+  @override
+  void addBackendMember(Element element) => _unsupported('addBackendMember');
+
+  @override
+  void forEachBackendMember(void f(Element member)) {
+    _unsupported('forEachBackendMember');
+  }
+
+  @override
+  bool get hasBackendMembers => _unsupported('hasBackendMembers');
+
+  @override
+  bool get hasConstructor => _unsupported('hasConstructor');
+
+  @override
+  bool hasFieldShadowedBy(Element fieldMember) => _unsupported('');
+
+  @override
+  bool get hasIncompleteHierarchy => _unsupported('hasIncompleteHierarchy');
+
+  @override
+  bool get hasLocalScopeMembers => _unsupported('hasLocalScopeMembers');
+
+  @override
+  bool implementsFunction(CoreClasses coreClasses) {
+    return _unsupported('implementsFunction');
+  }
+
+  @override
+  bool get isEnumClass => false;
+
+  @override
+  Element lookupBackendMember(String memberName) {
+    return _unsupported('lookupBackendMember');
+  }
+
+  @override
+  ConstructorElement lookupDefaultConstructor() {
+    ConstructorElement constructor = lookupConstructor("");
+    if (constructor != null && constructor.parameters.isEmpty) {
+      return constructor;
+    }
+    return null;
+  }
+
+  @override
+  void reverseBackendMembers() => _unsupported('reverseBackendMembers');
+
+  @override
+  ClassElement get superclass => supertype != null ? supertype.element : null;
+
+  @override
+  void ensureResolved(Resolution resolution) {
+    resolution.registerClass(this);
+  }
+
+}
+
 class ClassElementZ extends DeserializedElementZ
     with AnalyzableElementMixin,
          AstElementMixin,
          ClassElementCommon,
          class_members.ClassMemberMixin,
          ContainerMixin,
          LibraryMemberMixin,
-         TypeDeclarationMixin<InterfaceType>
+         TypeDeclarationMixin<InterfaceType>,
+         ClassElementMixin
     implements ClassElement {
   bool _isObject;
   DartType _supertype;
   OrderedTypeSet _allSupertypesAndSelf;
   Link<DartType> _interfaces;
 
   ClassElementZ(ObjectDecoder decoder)
       : super(decoder);
 
-  InterfaceType _createType(List<DartType> typeArguments) {
-    return new InterfaceType(this, typeArguments);
+  @override
+  List<DartType> _getTypeVariables() {
+    return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
+  }
+
+  void _ensureSuperHierarchy() {
+    if (_interfaces == null) {
+      InterfaceType supertype =
+          _decoder.getType(Key.SUPERTYPE, isOptional: true);
+      if (supertype == null) {
+        _isObject = true;
+        _allSupertypesAndSelf = new OrderedTypeSet.singleton(thisType);
+        _interfaces = const Link<DartType>();
+      } else {
+        _isObject = false;
+        _interfaces = toLink(
+            _decoder.getTypes(Key.INTERFACES, isOptional: true));
+        List<InterfaceType> mixins =
+            _decoder.getTypes(Key.MIXINS, isOptional: true);
+        for (InterfaceType mixin in mixins) {
+          MixinApplicationElement mixinElement =
+              new UnnamedMixinApplicationElementZ(this, supertype, mixin);
+          supertype = mixinElement.thisType.subst(
+              typeVariables, mixinElement.typeVariables);
+        }
+        _supertype = supertype;
+        _allSupertypesAndSelf =
+            new OrderedTypeSetBuilder(this)
+              .createOrderedTypeSet(_supertype, _interfaces);
+      }
+    }
   }
 
   @override
-  ElementKind get kind => ElementKind.CLASS;
-
-  @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClassElement(this, arg);
   }
 
   @override
   DartType get supertype {
-    if (_isObject == null) {
-      _supertype = _decoder.getType(Key.SUPERTYPE, isOptional: true);
-      _isObject = _supertype == null;
-    }
+    _ensureSuperHierarchy();
     return _supertype;
   }
 
   @override
   bool get isAbstract => _decoder.getBool(Key.IS_ABSTRACT);
 
   @override
   bool get isObject {
-    return supertype == null;
+    _ensureSuperHierarchy();
+    return _isObject;
   }
 
   @override
-  void addBackendMember(Element element) => _unsupported('addBackendMember');
+  OrderedTypeSet get allSupertypesAndSelf {
+    _ensureSuperHierarchy();
+    return _allSupertypesAndSelf;
+  }
+
+  @override
+  Link<DartType> get interfaces {
+    _ensureSuperHierarchy();
+    return _interfaces;
+  }
+
+  @override
+  bool get isProxy => _decoder.getBool(Key.IS_PROXY);
+
+  @override
+  bool get isUnnamedMixinApplication => false;
+}
+
+abstract class MixinApplicationElementMixin
+    implements ElementZ, MixinApplicationElement {
+  Link<ConstructorElement> _constructors;
+
+  @override
+  bool get isMixinApplication => false;
+
+  @override
+  ClassElement get mixin => mixinType.element;
+
+  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));
+        }
+      }
+      _constructors = builder.toLink();
+    }
+    return _constructors;
+  }
+}
+
+
+class NamedMixinApplicationElementZ extends ClassElementZ
+    with MixinApplicationElementCommon,
+         MixinApplicationElementMixin {
+  InterfaceType _mixinType;
+
+  NamedMixinApplicationElementZ(ObjectDecoder decoder)
+      : super(decoder);
+
+  @override
+  InterfaceType get mixinType {
+    if (_mixinType == null) {
+      _mixinType = _decoder.getType(Key.MIXIN);
+    }
+    return _mixinType;
+  }
+}
+
+
+class UnnamedMixinApplicationElementZ extends ElementZ
+    with ClassElementCommon,
+         ClassElementMixin,
+         class_members.ClassMemberMixin,
+         TypeDeclarationMixin<InterfaceType>,
+         AnalyzableElementMixin,
+         AstElementMixin,
+         MixinApplicationElementCommon,
+         MixinApplicationElementMixin {
+  final String name;
+  final ClassElement _subclass;
+  final InterfaceType supertype;
+  final Link<DartType> interfaces;
+  OrderedTypeSet _allSupertypesAndSelf;
+
+  UnnamedMixinApplicationElementZ(
+      ClassElement subclass,
+      InterfaceType supertype, InterfaceType mixin)
+      : this._subclass = subclass,
+        this.supertype = supertype,
+        this.interfaces = const Link<DartType>().prepend(mixin),
+        this.name = "${supertype.name}+${mixin.name}";
+
+  @override
+  CompilationUnitElement get compilationUnit => _subclass.compilationUnit;
+
+  @override
+  bool get isUnnamedMixinApplication => true;
+
+  @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) {
+      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) {
+      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
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitMixinApplicationElement(this, arg);
+  }
 
   @override
   OrderedTypeSet get allSupertypesAndSelf {
     if (_allSupertypesAndSelf == null) {
-      ObjectDecoder supertypesDeserializer =
-          _decoder.getObject(Key.SUPERTYPES);
-      List<int> offsets = supertypesDeserializer.getInts(Key.OFFSETS);
-      List<Link<DartType>> levels = new List<Link<DartType>>(offsets.length);
-      LinkBuilder<DartType> typesBuilder = new LinkBuilder<DartType>();
-      int offset = 0;
-      int depth = offsets.length - 1;
-      for (DartType type in supertypesDeserializer.getTypes(Key.TYPES)) {
-        Link<DartType> link = typesBuilder.addLast(type);
-        if (offsets[depth] == offset) {
-          levels[depth] = link;
-          depth--;
-        }
-        offset++;
-      }
-      LinkBuilder<DartType> supertypesBuilder = new LinkBuilder<DartType>();
-      for (DartType supertype in
-          supertypesDeserializer.getTypes(Key.SUPERTYPES, isOptional: true)) {
-        supertypesBuilder.addLast(supertype);
-      }
-      Link<DartType> types = typesBuilder.toLink();
-      Link<DartType> supertypes = supertypesBuilder.toLink();
-      _allSupertypesAndSelf = new OrderedTypeSet.internal(
-          levels, types, supertypes);
+      _allSupertypesAndSelf =
+          new OrderedTypeSetBuilder(this)
+            .createOrderedTypeSet(supertype, interfaces);
     }
     return _allSupertypesAndSelf;
   }
 
   @override
-  void forEachBackendMember(void f(Element member)) {
-    _unsupported('forEachBackendMember');
-  }
+  Element get enclosingElement => _subclass.enclosingElement;
 
   @override
-  bool get hasBackendMembers => _unsupported('hasBackendMembers');
+  bool get isObject => false;
 
   @override
-  bool get hasConstructor => _unsupported('hasConstructor');
+  bool get isProxy => false;
 
   @override
-  bool hasFieldShadowedBy(Element fieldMember) => _unsupported('');
+  LibraryElement get library => enclosingElement.library;
 
   @override
-  bool get hasIncompleteHierarchy => _unsupported('hasIncompleteHierarchy');
+  InterfaceType get mixinType => interfaces.head;
 
   @override
-  bool get hasLocalScopeMembers => _unsupported('hasLocalScopeMembers');
-
-  @override
-  bool implementsFunction(CoreClasses coreClasses) {
-    return _unsupported('implementsFunction');
-  }
-
-  @override
-  Link<DartType> get interfaces {
-    if (_interfaces == null) {
-      _interfaces = toLink(
-          _decoder.getTypes(Key.INTERFACES, isOptional: true));
-    }
-    return _interfaces;
-  }
-
-  @override
-  bool get isEnumClass => false;
-
-  @override
-  bool get isProxy => _decoder.getBool(Key.IS_PROXY);
-
-  @override
-  bool get isUnnamedMixinApplication {
-    return _decoder.getBool(Key.IS_UNNAMED_MIXIN_APPLICATION,
-        isOptional: true, defaultValue: false);
-  }
-
-  @override
-  Element lookupBackendMember(String memberName) {
-    return _unsupported('lookupBackendMember');
-  }
-
-  @override
-  ConstructorElement lookupDefaultConstructor() {
-    ConstructorElement constructor = lookupConstructor("");
-    if (constructor != null && constructor.parameters.isEmpty) {
-      return constructor;
-    }
-    return null;
-  }
-
-  @override
-  void reverseBackendMembers() => _unsupported('reverseBackendMembers');
-
-  @override
-  ClassElement get superclass => supertype != null ? supertype.element : null;
-
-  @override
-  void ensureResolved(Resolution resolution) {
-    resolution.registerClass(this);
-  }
+  SourceSpan get sourcePosition => _subclass.sourcePosition;
 }
 
 
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
 
   EnumClassElementZ(ObjectDecoder decoder)
       : super(decoder);
 
   @override
@@ skipping 114 matching lines @@
       : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 
   @override
   bool get isEffectiveTargetMalformed =>
       _unsupported('isEffectiveTargetMalformed');
 }
 
+class ForwardingConstructorElementZ extends ElementZ
+    with AnalyzableElementMixin,
+        AstElementMixin
+    implements ConstructorElement {
+  final MixinApplicationElement enclosingClass;
+  final ConstructorElement definingConstructor;
+
+  ForwardingConstructorElementZ(this.enclosingClass, this.definingConstructor);
+
+  @override
+  CompilationUnitElement get compilationUnit => enclosingClass.compilationUnit;
+
+  @override
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitConstructorElement(this, arg);
+  }
+
+  @override
+  AsyncMarker get asyncMarker => AsyncMarker.SYNC;
+
+  @override
+  InterfaceType computeEffectiveTargetType(InterfaceType newType) {
+    return enclosingClass.thisType;
+  }
+
+  @override
+  DartType computeType(Resolution resolution) => type;
+
+  @override
+  bool get isConst => false;
+
+  @override
+  ConstantConstructor get constantConstructor => null;
+
+  @override
+  ConstructorElement get effectiveTarget => this;
+
+  @override
+  Element get enclosingElement => enclosingClass;
+
+  @override
+  FunctionSignature get functionSignature {
+    return _unsupported('functionSignature');
+  }
+
+  @override
+  bool get hasFunctionSignature  {
+    return _unsupported('hasFunctionSignature');
+  }
+
+  @override
+  ConstructorElement get immediateRedirectionTarget => null;
+
+  @override
+  bool get isCyclicRedirection => false;
+
+  @override
+  bool get isEffectiveTargetMalformed => false;
+
+  @override
+  bool get isExternal => false;
+
+  @override
+  bool get isFromEnvironmentConstructor => false;
+
+  @override
+  bool get isRedirectingFactory => false;
+
+  @override
+  bool get isRedirectingGenerative => false;
+
+  @override
+  ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
+
+  @override
+  LibraryElement get library => enclosingClass.library;
+
+  @override
+  MemberElement get memberContext => this;
+
+  @override
+  Name get memberName => definingConstructor.memberName;
+
+  @override
+  String get name => definingConstructor.name;
+
+  @override
+  List<FunctionElement> get nestedClosures => const <FunctionElement>[];
+
+  @override
+  List<ParameterElement> get parameters {
+    // TODO(johnniwinther): We need to create synthetic parameters that
+    // substitute type variables.
+    return definingConstructor.parameters;
+  }
+
+  // TODO: implement redirectionDeferredPrefix
+  @override
+  PrefixElement get redirectionDeferredPrefix => null;
+
+  @override
+  SourceSpan get sourcePosition => enclosingClass.sourcePosition;
+
+  @override
+  FunctionType get type {
+    // TODO(johnniwinther): Ensure that the function type substitutes type
+    // variables correctly.
+    return definingConstructor.type;
+  }
+}
+
 abstract class MemberElementMixin
     implements DeserializedElementZ, MemberElement {
 
   @override
   MemberElement get memberContext => this;
 
   @override
   Name get memberName => new Name(name, library);
 
   @override
@@ skipping 222 matching lines @@
       : super(decoder);
 }
 
 class InstanceSetterElementZ extends SetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
   InstanceSetterElementZ(ObjectDecoder decoder)
       : super(decoder);
 }
 
 abstract class TypeDeclarationMixin<T extends GenericType>
-    implements DeserializedElementZ, TypeDeclarationElement {
+    implements ElementZ, TypeDeclarationElement {
   List<DartType> _typeVariables;
   T _rawType;
   T _thisType;
   Name _memberName;
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
 
+  List<DartType> _getTypeVariables();
+
   void _ensureTypes() {
     if (_typeVariables == null) {
-      _typeVariables = _decoder.getTypes(
-          Key.TYPE_VARIABLES, isOptional: true);
+      _typeVariables = _getTypeVariables();
       _rawType = _createType(new List<DartType>.filled(
           _typeVariables.length, const DynamicType()));
       _thisType = _createType(_typeVariables);
     }
   }
 
   T _createType(List<DartType> typeArguments);
 
   @override
   List<DartType> get typeVariables {
@@ skipping 30 matching lines @@
   DartType _alias;
 
   TypedefElementZ(ObjectDecoder decoder)
       : super(decoder);
 
   TypedefType _createType(List<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   @override
+  List<DartType> _getTypeVariables() {
+    return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
+  }
+
+  @override
   ElementKind get kind => ElementKind.TYPEDEF;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   @override
   DartType get alias {
     if (_alias == null) {
@@ skipping 64 matching lines @@
     if (_bound == null) {
       _bound = _decoder.getType(Key.BOUND);
     }
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 }
 
+class SyntheticTypeVariableElementZ extends ElementZ
+    with AnalyzableElementMixin,
+         AstElementMixin
+    implements TypeVariableElement {
+  final TypeDeclarationElement typeDeclaration;
+  final int index;
+  final String name;
+  TypeVariableType _type;
+  DartType _bound;
+  Name _memberName;
+
+  SyntheticTypeVariableElementZ(this.typeDeclaration, this.index, this.name);
+
+  Name get memberName {
+    if (_memberName == null) {
+      _memberName = new Name(name, library);
+    }
+    return _memberName;
+  }
+
+  @override
+  ElementKind get kind => ElementKind.TYPE_VARIABLE;
+
+  @override
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitTypeVariableElement(this, arg);
+  }
+
+  @override
+  CompilationUnitElement get compilationUnit {
+    return typeDeclaration.compilationUnit;
+  }
+
+  @override
+  TypeVariableType get type {
+    assert(invariant(this, _type != null,
+         message: "Type variable type has not been set on $this."));
+    return _type;
+  }
+
+  @override
+  TypeVariableType computeType(Resolution resolution) => type;
+
+  @override
+  Element get enclosingElement => typeDeclaration;
+
+  @override
+  Element get enclosingClass => typeDeclaration;
+
+  DartType get bound {
+    assert(invariant(this, _bound != null,
+        message: "Type variable bound has not been set on $this."));
+    return _bound;
+  }
+
+  @override
+  LibraryElement get library => typeDeclaration.library;
+
+  @override
+  SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
+}
+
 class ParameterElementZ extends DeserializedElementZ
     with AnalyzableElementMixin,
          AstElementMixin,
          TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
   DartType _type;
 
   ParameterElementZ(ObjectDecoder decoder) : super(decoder);
@@ skipping 209 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }