Make computeSignature private to modelx.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import '../common/resolution.dart' show
     Resolution,
     Parsing;
 import '../compiler.dart' show
@@ skipping 297 matching lines @@
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
   get constantConstructor => null;
 
   bool get isRedirectingGenerative => unsupported();
   bool get isRedirectingFactory => unsupported();
 
-  computeSignature(Resolution resolution) => unsupported();
   computeType(Resolution resolution) => unsupported();
 
   bool get hasFunctionSignature => false;
 
   get effectiveTarget => this;
 
   computeEffectiveTargetType(InterfaceType newType) => unsupported();
 
   get definingConstructor => null;
 
@@ skipping 60 matching lines @@
   }
 
   get effectiveTargetType {
     throw new UnsupportedError("effectiveTargetType");
   }
 
   set effectiveTargetType(_) {
     throw new UnsupportedError("effectiveTargetType=");
   }
 
+  void _computeSignature(Resolution resolution) {
+    throw new UnsupportedError("_computeSignature");
+  }
+
   get typeCache {
     throw new UnsupportedError("typeCache");
   }
 
   set typeCache(_) {
     throw new UnsupportedError("typeCache=");
   }
 
   get immediateRedirectionTarget {
     throw new UnsupportedError("immediateRedirectionTarget");
   }
 
   set immediateRedirectionTarget(_) {
     throw new UnsupportedError("immediateRedirectionTarget=");
   }
 
   get functionSignatureCache {
     throw new UnsupportedError("functionSignatureCache");
   }
 
   set functionSignatureCache(_) {
     throw new UnsupportedError("functionSignatureCache=");
   }
 
+  set functionSignature(_) {
+    throw new UnsupportedError("functionSignatureCache=");
+  }
+
   get nestedClosures {
     throw new UnsupportedError("nestedClosures");
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
   set redirectionDeferredPrefix(_) {
     throw new UnsupportedError("redirectionDeferredPrefix=");
@@ skipping 1535 matching lines @@
   bool get isExternal => modifiers.isExternal;
 
   bool get isInstanceMember {
     return isClassMember
            && !isConstructor
            && !isStatic;
   }
 
   bool get hasFunctionSignature => functionSignatureCache != null;
 
-  FunctionSignature computeSignature(Resolution resolution) {
-    if (functionSignatureCache != null) return functionSignatureCache;
-    functionSignatureCache = resolution.resolveSignature(this);
+  void _computeSignature(Resolution resolution) {
+    if (hasFunctionSignature) return;
+    functionSignature = resolution.resolveSignature(this);
+  }
+
+  FunctionSignature get functionSignature {
+    assert(invariant(this, hasFunctionSignature,
+        message: "Function signature has not been computed for $this."));
     return functionSignatureCache;
   }
 
-  FunctionSignature get functionSignature {
-    assert(invariant(this, functionSignatureCache != null,
-        message: "Function signature has not been computed for $this."));
-    return functionSignatureCache;
+  void set functionSignature(FunctionSignature value) {

[sigurdm, 2015/10/07 11:53:07]

The setter could be pushed down the element class-hierarchy to where it is
actually needed.

[Johnni Winther, 2015/10/07 12:15:03]

This is currently the lowest common point.

+    // TODO(johnniwinther): Strengthen the invariant to `!hasFunctionSignature`
+    // when checked mode checks are not enqueued eagerly.
+    assert(invariant(this, !hasFunctionSignature || type == value.type,
+        message: "Function signature has already been computed for $this."));
+    functionSignatureCache = value;

[sigurdm, 2015/10/07 11:53:07]

functionSignaturePrivate could be private

[Johnni Winther, 2015/10/07 12:15:03]

Done.

+    typeCache = functionSignatureCache.type;
   }
 
   List<ParameterElement> get parameters {
     // TODO(johnniwinther): Store the list directly, possibly by using List
     // instead of Link in FunctionSignature.
     List<ParameterElement> list = <ParameterElement>[];
     functionSignature.forEachParameter((e) => list.add(e));
     return list;
   }
 
   FunctionType computeType(Resolution resolution) {
     if (typeCache != null) return typeCache;
-    typeCache = computeSignature(resolution).type;
+    _computeSignature(resolution);
+    assert(invariant(this, typeCache != null,
+        message: "Type cache expected to be set on $this."));
     return typeCache;
   }
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionElement asFunctionElement() => this;
@@ skipping 215 matching lines @@
 
 class DeferredLoaderGetterElementX extends GetterElementX
     implements GetterElement {
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super("loadLibrary",
               Modifiers.EMPTY,
               prefix,
-              false);
-
-  FunctionSignature computeSignature(Resolution resolution) {
-    if (functionSignatureCache != null) return functionSignature;
-    functionSignatureCache =
-        new FunctionSignatureX(type: new FunctionType(this));
-    return functionSignatureCache;
+              false) {
+    functionSignature = new FunctionSignatureX(type: new FunctionType(this));
   }
 
   bool get isClassMember => false;
 
   bool get isSynthesized => true;
 
   bool get isDeferredLoaderGetter => true;
 
   bool get isTopLevel => true;
   // By having position null, the enclosing elements location is printed in
@@ skipping 13 matching lines @@
 class ConstructorBodyElementX extends BaseFunctionElementX
     implements ConstructorBodyElement {
   ConstructorElementX constructor;
 
   ConstructorBodyElementX(ConstructorElementX constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement) {
-    functionSignatureCache = constructor.functionSignature;
+    functionSignature = constructor.functionSignature;
   }
 
   bool get hasNode => constructor.hasNode;
 
   FunctionExpression get node => constructor.node;
 
   List<MetadataAnnotation> get metadata => constructor.metadata;
 
   bool get isInstanceMember => true;
 
@@ skipping 36 matching lines @@
               Modifiers.EMPTY,
               enclosing) ;
 
   SynthesizedConstructorElementX.forDefault(this.definingConstructor,
                                             Element enclosing)
       : isDefaultConstructor = true,
         super('',
               ElementKind.GENERATIVE_CONSTRUCTOR,
               Modifiers.EMPTY,
               enclosing) {
-    typeCache = new FunctionType.synthesized(enclosingClass.thisType);
-    functionSignatureCache = new FunctionSignatureX(type: type);
+    functionSignature = new FunctionSignatureX(
+        type: new FunctionType.synthesized(enclosingClass.thisType));
   }
 
   FunctionExpression parseNode(Parsing parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   DartType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
-  FunctionSignature computeSignature(Resolution resolution) {
-    if (functionSignatureCache != null) return functionSignatureCache;
+  void _computeSignature(Resolution resolution) {
+    if (hasFunctionSignature) return;
     if (definingConstructor.isErroneous) {
-      typeCache = new FunctionType.synthesized(enclosingClass.thisType);
-      return functionSignatureCache = new FunctionSignatureX(type: type);
+      functionSignature = new FunctionSignatureX(
+          type: new FunctionType.synthesized(enclosingClass.thisType));
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     definingConstructor.computeType(resolution);
-    functionSignatureCache = definingConstructor.functionSignature;
-    typeCache = definingConstructor.type;
-    return functionSignatureCache;
+    functionSignature = definingConstructor.functionSignature;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 }
 
 abstract class TypeDeclarationElementX<T extends GenericType>
     implements TypeDeclarationElement {
   /**
@@ skipping 727 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }