Support argument definition test in constructors.

lib/compiler/implementation/ssa/builder.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.
 
 part of ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 849 matching lines @@
 class SsaBuilder extends ResolvedVisitor implements Visitor {
   final SsaBuilderTask builder;
   final JavaScriptBackend backend;
   final Interceptors interceptors;
   final WorkItem work;
   final ConstantSystem constantSystem;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
-  Map<Element, HParameterValue> parameters;
+  Map<Element, HInstruction> parameters;
   final RuntimeTypeInformation rti;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   /**
    * Variables stored in the current activation. These variables are
    * being updated in try/catch blocks, and should be
    * accessed indirectly through [HLocalGet] and [HLocalSet].
    */
   Map<Element, HLocalValue> activationVariables;
@@ skipping 19 matching lines @@
   SsaBuilder(this.constantSystem, SsaBuilderTask builder, WorkItem work)
     : this.builder = builder,
       this.backend = builder.backend,
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       activationVariables = new Map<Element, HLocalValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>(),
-      parameters = new Map<Element, HParameterValue>(),
+      parameters = new Map<Element, HInstruction>(),
       sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
       rti = builder.compiler.codegenWorld.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 100;
   List<InliningState> inliningStack;
@@ skipping 225 matching lines @@
 
       sourceElementStack.add(constructor.enclosingElement);
       buildFieldInitializers(constructor.enclosingElement.implementation,
                              fieldValues);
       sourceElementStack.removeLast();
 
       int index = 0;
       FunctionSignature params = constructor.computeSignature(compiler);
       params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
+        // Because we are inlining the initializer, we must update
+        // what was given as parameter. This will be used in case
+        // there is a parameter check expression in the initializer.
+        parameters[parameter] = argument;
         localsHandler.updateLocal(parameter, argument);
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.kind == ElementKind.FIELD_PARAMETER) {
           FieldParameterElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       TreeElements oldElements = elements;
       elements =
           compiler.enqueuer.resolution.getCachedElements(constructor);
+
+      ClosureClassMap oldClosureData = localsHandler.closureData;
+      localsHandler.closureData =
+          compiler.closureToClassMapper.computeClosureToClassMapping(
+              constructor, constructor.parseNode(compiler), elements);
+
+      params.orderedForEachParameter((Element parameterElement) {
+        if (elements.isParameterChecked(parameterElement)) {
+          addParameterCheckInstruction(parameterElement);
+        }
+      });
+
       buildInitializers(constructor, constructors, fieldValues);
+      localsHandler.closureData = oldClosureData;
       elements = oldElements;
     });
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
@@ skipping 169 matching lines @@
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body == null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       FunctionSignature functionSignature = body.computeSignature(compiler);
       int arity = functionSignature.parameterCount;
       functionSignature.orderedForEachParameter((parameter) {
         bodyCallInputs.add(localsHandler.readLocal(parameter));
       });
+
+      // If parameters are checked, we pass what we already computed

[floitsch, 2012/10/29 21:45:45]

If parameters are checked, we pass the already computed boolean to the
constructor body.

[ngeoffray, 2012/10/30 09:34:46]

Done.

+      // for checking it to the constructor body.
+      TreeElements elements =
+          compiler.enqueuer.resolution.getCachedElements(constructor);
+      Node node = constructor.parseNode(compiler);
+      ClosureClassMap parameterClosureData =
+          compiler.closureToClassMapper.getMappingForNestedFunction(node);
+      functionSignature.orderedForEachParameter((parameter) {
+        if (elements.isParameterChecked(parameter)) {
+          Element fieldCheck =
+              parameterClosureData.parametersWithSentinel[parameter];
+          bodyCallInputs.add(localsHandler.readLocal(fieldCheck));
+        }
+      });
+
       // TODO(ahe): The constructor name is statically resolved. See
       // SsaCodeGenerator.visitInvokeDynamicMethod. Is there a cleaner
       // way to do this?
       SourceString name =
           new SourceString(backend.namer.getName(body.declaration));
       // TODO(kasperl): This seems fishy. We shouldn't be inventing all
       // these selectors. Maybe the resolver can do more of the work
       // for us here?
       LibraryElement library = body.getLibrary();
       Selector selector = new Selector.call(name, library, arity);
       HInvokeDynamic invoke =
           new HInvokeDynamicMethod(selector, bodyCallInputs);
       invoke.element = body;
       add(invoke);
     }
     close(new HReturn(newObject)).addSuccessor(graph.exit);
     return closeFunction();
   }
 
   void addParameterCheckInstruction(Element element) {
-    // This is the code we emit for a parameter that is being checked
-    // on whether it was given at value at the call site:
-    //
-    // foo([a = 42) {
-    //   if (?a) print('parameter passed $a');
-    // }
-    //
-    // foo([a = 42]) {
-    //   var t1 = a === sentinel;
-    //   if (t1) a = 42;
-    //   if (!t1) print('parameter passed ' + a);
-    // }
+    HInstruction check;

[floitsch, 2012/10/29 21:45:45]

Keep the declaration at the use-point. No need to move it outside the if's. It
actually makes the method one line longer...

[ngeoffray, 2012/10/30 09:34:46]

The variable is used outside the if/else (line 1462), so I'm keeping the
declaration here.

+    Element checkResultElement =
+        localsHandler.closureData.parametersWithSentinel[element];
+    if (currentElement.isGenerativeConstructorBody()) {
+      // A generative constructor body gets the information that a
+      // parameter was passed in extra parameters.

[floitsch, 2012/10/29 21:45:45]

A generative constructor body receives extra parameters that indicate if a
parameter was passed to the factory.

[ngeoffray, 2012/10/30 09:34:46]

Done.

+      check = new HParameterValue(checkResultElement);
+      add(check);
+    } else {

[floitsch, 2012/10/29 21:45:45]

You could avoid the else (and the indentation) by just returning in the special
case. But I'm fine the way it is.

[ngeoffray, 2012/10/30 09:34:46]

No, there's a shared updateLocal call line 1462.

+      // This is the code we emit for a parameter that is being checked
+      // on whether it was given at value at the call site:
+      //
+      // foo([a = 42) {
+      //   if (?a) print('parameter passed $a');
+      // }
+      //
+      // foo([a = 42]) {
+      //   var t1 = a === sentinel;
+      //   if (t1) a = 42;
+      //   if (!t1) print('parameter passed ' + a);
+      // }
 
-    // Fetch the original default value of [element];
-    ConstantHandler handler = compiler.constantHandler;
-    Constant constant = handler.compileVariable(element);
-    HConstant defaultValue = constant == null
-        ? graph.addConstantNull(constantSystem)
-        : graph.addConstant(constant);
+      // Fetch the original default value of [element];
+      ConstantHandler handler = compiler.constantHandler;
+      Constant constant = handler.compileVariable(element);
+      HConstant defaultValue = constant == null
+          ? graph.addConstantNull(constantSystem)
+          : graph.addConstant(constant);
 
-    // Emit the equality check with the sentinel.
-    HConstant sentinel = graph.addConstant(SentinelConstant.SENTINEL);
-    Element equalsHelper = interceptors.getTripleEqualsInterceptor();
-    HInstruction target = new HStatic(equalsHelper);
-    add(target);
-    HInstruction operand = parameters[element];
-    HInstruction check = new HIdentity(target, sentinel, operand);
-    add(check);
+      // Emit the equality check with the sentinel.
+      HConstant sentinel = graph.addConstant(SentinelConstant.SENTINEL);
+      Element equalsHelper = interceptors.getTripleEqualsInterceptor();
+      HInstruction target = new HStatic(equalsHelper);
+      add(target);
+      HInstruction operand = parameters[element];
+      check = new HIdentity(target, sentinel, operand);
+      add(check);
 
-    // If the check succeeds, we must update the parameter with the
-    // default value.
-    handleIf(element.parseNode(compiler),
-             () => stack.add(check),
-             () => localsHandler.updateLocal(element, defaultValue),
-             null);
+      // If the check succeeds, we must update the parameter with the
+      // default value.
+      handleIf(element.parseNode(compiler),
+               () => stack.add(check),
+               () => localsHandler.updateLocal(element, defaultValue),
+               null);
 
-    // Create the instruction that parameter checks will use.
-    check = new HNot(check);
-    add(check);
+      // Create the instruction that parameter checks will use.
+      check = new HNot(check);
+      add(check);
+    }
 
-    ClosureClassMap closureData = localsHandler.closureData;
-    Element checkResultElement = closureData.parametersWithSentinel[element];
     localsHandler.updateLocal(checkResultElement, check);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be the implementation element.
    */
   void openFunction(Element element, Expression node) {
     assert(invariant(element, element.isImplementation));
@@ skipping 3119 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }