Codegen support for the argument definition test.

lib/compiler/implementation/closure.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("closureToClassMapper");
 
 #import("elements/elements.dart");
 #import("leg.dart");
 #import("scanner/scannerlib.dart");
 #import("tree/tree.dart");
 #import("util/util.dart");
 
 class ClosureTask extends CompilerTask {
   Map<Node, ClosureClassMap> closureMappingCache;
   ClosureTask(Compiler compiler)
       : closureMappingCache = new Map<Node, ClosureClassMap>(),
         super(compiler);
 
   String get name => "Closure Simplifier";
 
   ClosureClassMap computeClosureToClassMapping(FunctionExpression node,
-                                                     TreeElements elements) {
+                                               TreeElements elements) {
     return measure(() {
       ClosureClassMap cached = closureMappingCache[node];
       if (cached !== null) return cached;
 
       ClosureTranslator translator =
           new ClosureTranslator(compiler, elements, closureMappingCache);
       // The translator will store the computed closure-mappings inside the
       // cache. One for given method and one for each nested closure.
       translator.translate(node);
       assert(closureMappingCache[node] != null);
@@ skipping 101 matching lines @@
 
   // Maps scopes ([Loop] and [FunctionExpression] nodes) to their
   // [ClosureScope] which contains their box and the
   // captured variables that are stored in the box.
   // This map will be empty if the method/closure of this [ClosureData] does not
   // contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes;
 
   final Set<Element> usedVariablesInTry;
 
+  // A map from the parameter element to the variable element that
+  // holds the sentinel check.
+  final Map<Element, Element> parametersWithSentinel;
+
   ClosureClassMap(this.closureElement,
               this.closureClassElement,
               this.callElement,
               this.thisElement)
       : this.freeVariableMapping = new Map<Element, Element>(),
         this.capturedFieldMapping = new Map<Element, Element>(),
         this.capturingScopes = new Map<Node, ClosureScope>(),
-        this.usedVariablesInTry = new Set<Element>();
+        this.usedVariablesInTry = new Set<Element>(),
+        this.parametersWithSentinel = new Map<Element, Element>();
 
   bool isClosure() => closureElement !== null;
 }
 
 class ClosureTranslator extends AbstractVisitor {
   final Compiler compiler;
   final TreeElements elements;
   int closureFieldCounter = 0;
   bool inTryStatement = false;
   final Map<Node, ClosureClassMap> closureMappingCache;
@@ skipping 143 matching lines @@
 
   visitSend(Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       useLocal(element);
     } else if (node.receiver === null &&
                Elements.isInstanceSend(node, elements)) {
       useLocal(closureData.thisElement);
     } else if (node.isSuperCall) {
       useLocal(closureData.thisElement);
+    } else if (node.isOperator
+               && node.argumentsNode is Prefix
+               && node.selector.source.stringValue == '?') {
+      Element parameter = elements[node.receiver];
+      FunctionElement enclosing = parameter.enclosingElement;
+      if (currentFunctionElement != enclosing) {
+        // If the parameter is from an outer function, we need to put
+        // the check in a field of the closure class.
+        FunctionExpression node = enclosing.parseNode(compiler);
+        ClosureClassMap cached = closureMappingCache[node];
+        if (!cached.parametersWithSentinel.containsKey(parameter)) {
+          SourceString parameterName = parameter.name;
+          String name = '${parameterName.slowToString()}_check';

[kasperl, 2012/09/04 10:50:08]

Is it a problem if this conflicts with other parameter/local names?

[ngeoffray, 2012/09/04 10:53:44]

No, the namer will disambiguate the elements.

+          Element newElement = new Element(new SourceString(name),
+                                           ElementKind.VARIABLE,
+                                           enclosing);
+          useLocal(newElement);
+          cached.parametersWithSentinel[parameter] = newElement;
+        }
+      }
     }
     node.visitChildren(this);
   }
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       mutatedVariables.add(element);
     }
     super.visitSendSet(node);
@@ skipping 146 matching lines @@
         // declared in the GENERATIVE_CONSTRUCTOR. Including the 'this'.
         Element thisEnclosingElement = element;
         if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
           ConstructorBodyElement body = element;
           thisEnclosingElement = body.constructor;
         }
         thisElement = new ThisElement(thisEnclosingElement);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
+    closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       // We have to declare the implicit 'this' parameter.
       if (!insideClosure && closureData.thisElement !== null) {
         declareLocal(closureData.thisElement);
       }
       // If we are inside a named closure we have to declare ourselve. For
       // simplicity we declare the local even if the closure does not have a
       // name.
       // It will simply not be used.
       if (insideClosure) {
         declareLocal(element);
       }
 
       // TODO(ahe): This is problematic. The backend should not repeat
       // the work of the resolver. It is the resolver's job to create
       // parameters, etc. Other phases should only visit statements.
       // TODO(floitsch): we avoid visiting the initializers on purpose so that
       // we get an error-message later in the builder.
       if (node.parameters !== null) node.parameters.accept(this);
       if (node.body !== null) node.body.accept(this);
     });
 
-    closureMappingCache[node] = closureData;
 
     ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
     currentFunctionElement = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
@@ skipping 16 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }