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 {
+  get _functionSignatureCache {
     throw new UnsupportedError("functionSignatureCache");
   }
 
-  set functionSignatureCache(_) {
+  set _functionSignatureCache(_) {
     throw new UnsupportedError("functionSignatureCache=");
   }
 
+  set functionSignature(_) {
+    throw new UnsupportedError("functionSignature=");
+  }
+
   get nestedClosures {
     throw new UnsupportedError("nestedClosures");
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
   set redirectionDeferredPrefix(_) {
     throw new UnsupportedError("redirectionDeferredPrefix=");
@@ skipping 1261 matching lines @@
     implements FormalElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
   DartType typeCache;
 
   /**
    * Function signature for a variable with a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    */
-  FunctionSignature functionSignatureCache;
+  FunctionSignature _functionSignatureCache;
 
   FormalElementX(ElementKind elementKind,
                  FunctionTypedElement enclosingElement,
                  this.definitions,
                  Identifier identifier)
       : this.identifier = identifier,
         super(identifier.source, elementKind, enclosingElement);
 
   FunctionTypedElement get functionDeclaration => enclosingElement;
 
   Modifiers get modifiers => definitions.modifiers;
 
   Token get position => identifier.getBeginToken();
 
   Node parseNode(Parsing parsing) => definitions;
 
   DartType computeType(Resolution resolution) {
     assert(invariant(this, type != null,
         message: "Parameter type has not been set for $this."));
     return type;
   }
 
   DartType get type {
     assert(invariant(this, typeCache != null,
             message: "Parameter type has not been set for $this."));
         return typeCache;
   }
 
   FunctionSignature get functionSignature {
-    assert(invariant(this, typeCache != null,
-            message: "Parameter signature has not been set for $this."));
-    return functionSignatureCache;
+    assert(invariant(this, _functionSignatureCache != null,
+        message: "Parameter signature has not been computed for $this."));
+    return _functionSignatureCache;
+  }
+
+  void set functionSignature(FunctionSignature value) {
+    assert(invariant(this, _functionSignatureCache == null,
+        message: "Parameter signature has already been computed for $this."));
+    _functionSignatureCache = value;
+    typeCache = _functionSignatureCache.type;
   }
 
   bool get hasNode => true;
 
   VariableDefinitions get node => definitions;
 
   FunctionType get functionType => type;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFormalElement(this, arg);
@@ skipping 199 matching lines @@
 }
 
 abstract class BaseFunctionElementX
     extends ElementX with PatchMixin<FunctionElement>, AstElementMixin
     implements FunctionElement {
   DartType typeCache;
   final Modifiers modifiers;
 
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
-  FunctionSignature functionSignatureCache;
+  FunctionSignature _functionSignatureCache;
 
   AsyncMarker asyncMarker = AsyncMarker.SYNC;
 
   BaseFunctionElementX(String name,
                        ElementKind kind,
                        Modifiers this.modifiers,
                        Element enclosing)
       : super(name, kind, enclosing) {
     assert(modifiers != null);
   }
 
   bool get isExternal => modifiers.isExternal;
 
   bool get isInstanceMember {
     return isClassMember
            && !isConstructor
            && !isStatic;
   }
 
-  bool get hasFunctionSignature => functionSignatureCache != null;
+  bool get hasFunctionSignature => _functionSignatureCache != null;
 
-  FunctionSignature computeSignature(Resolution resolution) {
-    if (functionSignatureCache != null) return functionSignatureCache;
-    functionSignatureCache = resolution.resolveSignature(this);
-    return functionSignatureCache;
+  void _computeSignature(Resolution resolution) {
+    if (hasFunctionSignature) return;
+    functionSignature = resolution.resolveSignature(this);
   }
 
   FunctionSignature get functionSignature {
-    assert(invariant(this, functionSignatureCache != null,
+    assert(invariant(this, hasFunctionSignature,
         message: "Function signature has not been computed for $this."));
-    return functionSignatureCache;
+    return _functionSignatureCache;
+  }
+
+  void set functionSignature(FunctionSignature value) {
+    // 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;
+    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 25 matching lines @@
                    ElementKind kind,
                    Modifiers modifiers,
                    Element enclosing)
       : super(name, kind, modifiers, enclosing);
 
   MemberElement get memberContext => this;
 
   void reuseElement() {
     super.reuseElement();
     nestedClosures.clear();
-    functionSignatureCache = null;
+    _functionSignatureCache = null;
     typeCache = null;
   }
 }
 
 abstract class MethodElementX extends FunctionElementX {
   final bool hasBody;
 
   MethodElementX(String name,
                  ElementKind kind,
                  Modifiers modifiers,
@@ skipping 169 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);
   }
 
 }