Serialize more properties of ConstructorElement.

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 12 matching lines @@
 import '../resolution/class_members.dart' as class_members;
 import '../resolution/scope.dart' show Scope;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../script.dart';
 import '../serialization/constant_serialization.dart';
 import '../tokens/token.dart' show Token;
 import '../tree/tree.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'keys.dart';
 import 'serialization.dart';
+import 'serialization_util.dart';
 
 /// Compute a [Link] from an [Iterable].
 Link toLink(Iterable iterable) {
   LinkBuilder builder = new LinkBuilder();
   for (var element in iterable) {
     builder.addLast(element);
   }
   return builder.toLink();
 }
 
@@ skipping 1015 matching lines @@
     with
         AnalyzableElementMixin,
         AstElementMixin,
         ClassMemberMixin,
         FunctionTypedElementMixin,
         ParametersMixin,
         TypedElementMixin,
         MemberElementMixin
     implements ConstructorElement {
   ConstantConstructor _constantConstructor;
+  ConstructorElement _effectiveTarget;
 
   ConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   @override
   bool get isConst => _decoder.getBool(Key.IS_CONST);
 
@@ skipping 18 matching lines @@
       }
       _constantConstructor = ConstantConstructorDeserializer.deserialize(data);
     }
     return _constantConstructor;
   }
 
   @override
   AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 
   @override
-  InterfaceType computeEffectiveTargetType(InterfaceType newType) {
-    return _unsupported('computeEffectiveTargetType');
-  }
-
-  @override
   ConstructorElement get definingConstructor {
-    return _unsupported('definingConstructor');
+    String name =
+        _decoder.getString(Key.DEFINING_CONSTRUCTOR, isOptional: true);
+    if (name != null) {
+      return enclosingClass.superclass.lookupConstructor(name);
+    }
+    return null;
   }
 
   @override
   ConstructorElement get effectiveTarget {
-    return _unsupported('effectiveTarget');
+    if (_effectiveTarget == null) {
+      _effectiveTarget =
+          _decoder.getElement(Key.EFFECTIVE_TARGET, isOptional: true);
+      if (_effectiveTarget == null) {
+        _effectiveTarget = this;
+      }
+    }
+    return _effectiveTarget;
   }
 
   @override
-  ConstructorElement get immediateRedirectionTarget {
-    return _unsupported('immediateRedirectionTarget');
-  }
+  ConstructorElement get immediateRedirectionTarget => null;
 
   @override
   bool get isEffectiveTargetMalformed {
     return _unsupported('isEffectiveTargetMalformed');
   }
 
   @override
-  bool get isRedirectingFactory => _unsupported('isRedirectingFactory');
-
-  @override
-  bool get isRedirectingGenerative => _unsupported('isRedirectingGenerative');
-
-  @override
   bool get isCyclicRedirection => _unsupported('isCyclicRedirection');
 
   @override
-  PrefixElement get redirectionDeferredPrefix {
-    return _unsupported('redirectionDeferredPrefix');
-  }
+  bool get isRedirectingFactory => false;
+
+  @override
+  bool get isRedirectingGenerative => false;
+
+  @override
+  PrefixElement get redirectionDeferredPrefix => null;
+
+  @override
+  InterfaceType computeEffectiveTargetType(InterfaceType newType) => newType;
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
   GenerativeConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
-  bool get isEffectiveTargetMalformed =>
-      _unsupported('isEffectiveTargetMalformed');
+  bool get isRedirectingGenerative => _decoder.getBool(Key.IS_REDIRECTING);
 }
 
 class FactoryConstructorElementZ extends ConstructorElementZ {
   FactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
+}
+
+class RedirectingFactoryConstructorElementZ extends ConstructorElementZ {
+  InterfaceType _effectiveTargetType;
+  ConstructorElement _immediateRedirectionTarget;
+  PrefixElement _redirectionDeferredPrefix;
+
+  RedirectingFactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
+
+  @override
+  ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 
   @override
-  bool get isEffectiveTargetMalformed =>
-      _unsupported('isEffectiveTargetMalformed');
+  bool get isRedirectingFactory => true;
+
+  void _ensureEffectiveTarget() {
+    if (_effectiveTarget == null) {
+      _effectiveTarget =
+          _decoder.getElement(Key.EFFECTIVE_TARGET, isOptional: true);
+      if (_effectiveTarget == null) {
+        _effectiveTarget = this;
+        _effectiveTargetType = enclosingClass.thisType;
+      } else {
+        _effectiveTargetType = _decoder.getType(Key.EFFECTIVE_TARGET_TYPE);
+      }
+    }
+  }
+
+  @override
+  ConstructorElement get effectiveTarget {
+    _ensureEffectiveTarget();
+    return _effectiveTarget;
+  }
+
+  @override
+  InterfaceType computeEffectiveTargetType(InterfaceType newType) {
+    _ensureEffectiveTarget();
+    return _effectiveTargetType.substByContext(newType);
+  }
+
+  void _ensureRedirection() {
+    if (_immediateRedirectionTarget == null) {
+      _immediateRedirectionTarget =
+          _decoder.getElement(Key.IMMEDIATE_REDIRECTION_TARGET);
+      _redirectionDeferredPrefix =
+          _decoder.getElement(Key.PREFIX, isOptional: true);
+    }
+  }
+
+  @override
+  ConstructorElement get immediateRedirectionTarget {

[Siggi Cherem (dart-lang), 2016/04/29 20:20:23]

optional suggestion, probably not worth it.

I'd either initialize them everything we can upfront in the constructor. Any
lazy field, I'd prefer to initialize on its own if that's possible. For example
these 2 redirection targets are technically always used together, but they could
easily be initialized each on their first use. 

ConstructorElement get immediateRedirectionTarget =>
    __immediateRedirectionTarget ??=
decoder.getElement(Key.IMMEDIATE_REDIRECTION_TARGET);

ConstructorElement get redirectionDeferredPRefix =>
    __immediateRedirectionTarget ??= decoder.getElement(Key.PREFIX, ...);



I think we can do something similar with effectiveTarget/Type, but again, might
not be worth it.

[Johnni Winther, 2016/04/30 09:04:46]

I think it's only really worthwhile to deserialize everything in the constructor
if we can free the [_decoder] and more importantly the object from which it
reads its data. With the current setup it is not directly possible but we need
to look into it when we focus on the serialization format.
Since [_redirectionDeferredPrefix] might be `null` ??= would make us decode on
each access. This is why I grouped it with [immediateRedirectionTarget].

[Siggi Cherem (dart-lang), 2016/05/02 16:58:35]

Yeah, I look forward to the new format. At that point we'll likely initialize
everything upfront: looking at Asger's numbers for the time spent loading data,
I expect it will be fast enough that it wont be worth making it lazy.
Ah, I see. Maybe we should consider initializing in constructors anything we
that says `isOptional`.

+    _ensureRedirection();
+    return _immediateRedirectionTarget;
+  }
+
+  @override
+  PrefixElement get redirectionDeferredPrefix {
+    _ensureRedirection();
+    return _redirectionDeferredPrefix;
+  }
 }
 
 class ForwardingConstructorElementZ extends ElementZ
     with AnalyzableElementMixin, AstElementMixin
     implements ConstructorElement {
   final MixinApplicationElement enclosingClass;
   final ConstructorElement definingConstructor;
 
   ForwardingConstructorElementZ(this.enclosingClass, this.definingConstructor);
 
@@ skipping 845 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }