Serialize more properties of ConstructorElement.

pkg/compiler/lib/src/serialization/modelz.dart

Index: pkg/compiler/lib/src/serialization/modelz.dart
diff --git a/pkg/compiler/lib/src/serialization/modelz.dart b/pkg/compiler/lib/src/serialization/modelz.dart
index e77d5c0925c5c208536f281d8d0e72c22483dcf7..2bfb6e13987cb7c3029e9e077c9940ef56bbdeb6 100644
--- a/pkg/compiler/lib/src/serialization/modelz.dart
+++ b/pkg/compiler/lib/src/serialization/modelz.dart
@@ -30,6 +30,7 @@ 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) {
@@ -1065,6 +1066,7 @@ abstract class ConstructorElementZ extends DeserializedElementZ
         MemberElementMixin
     implements ConstructorElement {
   ConstantConstructor _constantConstructor;
+  ConstructorElement _effectiveTarget;
 
   ConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
@@ -1103,24 +1105,29 @@ abstract class ConstructorElementZ extends DeserializedElementZ
   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 {
@@ -1128,18 +1135,19 @@ abstract class ConstructorElementZ extends DeserializedElementZ
   }
 
   @override
-  bool get isRedirectingFactory => _unsupported('isRedirectingFactory');
+  bool get isCyclicRedirection => _unsupported('isCyclicRedirection');
 
   @override
-  bool get isRedirectingGenerative => _unsupported('isRedirectingGenerative');
+  bool get isRedirectingFactory => false;
 
   @override
-  bool get isCyclicRedirection => _unsupported('isCyclicRedirection');
+  bool get isRedirectingGenerative => false;
 
   @override
-  PrefixElement get redirectionDeferredPrefix {
-    return _unsupported('redirectionDeferredPrefix');
-  }
+  PrefixElement get redirectionDeferredPrefix => null;
+
+  @override
+  InterfaceType computeEffectiveTargetType(InterfaceType newType) => newType;
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
@@ -1149,8 +1157,7 @@ class GenerativeConstructorElementZ extends ConstructorElementZ {
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
-  bool get isEffectiveTargetMalformed =>
-      _unsupported('isEffectiveTargetMalformed');
+  bool get isRedirectingGenerative => _decoder.getBool(Key.IS_REDIRECTING);
 }
 
 class FactoryConstructorElementZ extends ConstructorElementZ {
@@ -1158,10 +1165,66 @@ class FactoryConstructorElementZ extends ConstructorElementZ {
 
   @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