Support checked mode for field setters.

lib/compiler/implementation/elements/elements.dart

 // Copyright (c) 2012, 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');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 704 matching lines @@
     : super(null, kind, enclosing),
       this.cachedNode = node,
       this.modifiers = node.modifiers;
 
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
   Type computeType(Compiler compiler) {
     if (type != null) return type;
-    VariableDefinitions node = parseNode(compiler);
-    if (node.type !== null) {
-      type = compiler.resolveTypeAnnotation(this, node.type);
-    } else {
-      // Is node.definitions exactly one FunctionExpression?
-      Link<Node> link = node.definitions.nodes;
-      if (!link.isEmpty() &&
-          link.head.asFunctionExpression() !== null &&
-          link.tail.isEmpty()) {
-        FunctionExpression functionExpression = link.head;
-        // We found exactly one FunctionExpression
-        compiler.withCurrentElement(this, () {
-          functionSignature =
-              compiler.resolveFunctionExpression(this, functionExpression);
-        });
-        type = compiler.computeFunctionType(compiler.functionClass,
-                                            functionSignature);
+    compiler.withCurrentElement(this, () {
+      VariableDefinitions node = parseNode(compiler);
+      if (node.type !== null) {
+        type = compiler.resolveTypeAnnotation(this, node.type);
       } else {
-        type = compiler.types.dynamicType;
+        // Is node.definitions exactly one FunctionExpression?
+        Link<Node> link = node.definitions.nodes;
+        if (!link.isEmpty() &&
+            link.head.asFunctionExpression() !== null &&
+            link.tail.isEmpty()) {
+          FunctionExpression functionExpression = link.head;
+          // We found exactly one FunctionExpression
+          compiler.withCurrentElement(this, () {

[floitsch, 2012/08/30 14:35:14]

Is this still necessary?

[ngeoffray, 2012/08/30 17:10:21]

Good catch.

+            functionSignature =
+                compiler.resolveFunctionExpression(this, functionExpression);
+          });
+          type = compiler.computeFunctionType(compiler.functionClass,
+                                              functionSignature);
+        } else {
+          type = compiler.types.dynamicType;
+        }
       }
-    }
+    });
     assert(type != null);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 
   VariableListElement cloneTo(Element enclosing, DiagnosticListener listener) {
     VariableListElement result;
     if (cachedNode !== null) {
       result = new VariableListElement.node(cachedNode, kind, enclosing);
@@ skipping 893 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }