Support argument definition test in constructors.

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 68 matching lines @@
       // Use [work.element] to ensure that the parameter element come from
       // the declaration.
       FunctionElement function = work.element;
       function.computeSignature(compiler).forEachParameter((element) {
         compiler.enqueuer.codegen.addToWorkList(element, work.resolutionTree);
       });
       List<js.Parameter> parameters = <js.Parameter>[];
       parameterNames.forEach((element, name) {
         parameters.add(new js.Parameter(name));
       });
-      addTypeParameters(work.element, parameters, parameterNames);
+      addBackendParameters(work.element, parameters, parameterNames);
       String parametersString = Strings.join(parameterNames.values, ", ");
       SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
       js.Block body;
       ClassElement enclosingClass = element.getEnclosingClass();
       if (element.isInstanceMember()
           && enclosingClass.isNative()
@@ skipping 10 matching lines @@
         js.Node nativeCode = new js.LiteralStatement(buffer.toString());
         body = new js.Block(<js.Statement>[nativeCode]);
       } else {
         body = codegen.body;
       }
       js.Fun fun = buildJavaScriptFunction(element, parameters, body);
       return prettyPrint(fun);
     });
   }
 
-  void addTypeParameters(Element element,
-                         List<js.Parameter> parameters,
-                         Map<Element, String> parameterNames) {
-    if (!element.isConstructor()) return;
-    ClassElement cls = element.enclosingElement;
-    if (!compiler.world.needsRti(cls)) return;
-    cls.typeVariables.forEach((TypeVariableType typeVariable) {
-      String name = typeVariable.element.name.slowToString();
-      String prefix = '';
-      // Avoid collisions with real parameters of the method.
-      do {
-        name = JsNames.getValid('$prefix$name');
-        prefix = '\$$prefix';
-      } while (parameterNames.containsValue(name));
-      parameterNames[typeVariable.element] = name;
-      parameters.add(new js.Parameter(name));
-    });
+  void addBackendParameter(Element element,
+                           List<js.Parameter> parameters,
+                           Map<Element, String> parameterNames) {
+    String name = element.name.slowToString();
+    String prefix = '';
+    // Avoid collisions with real parameters of the method.
+    do {
+      name = JsNames.getValid('$prefix$name');
+      prefix = '\$$prefix';
+    } while (parameterNames.containsValue(name));
+    parameterNames[element] = name;
+    parameters.add(new js.Parameter(name));
+  }
+
+  void addBackendParameters(Element element,
+                            List<js.Parameter> parameters,
+                            Map<Element, String> parameterNames) {
+    // TODO(ngeoffray): We should infer this information from the
+    // graph, instead of recomputing what the builder did.
+    if (element.isConstructor()) {
+      // Put the type parameters.
+      ClassElement cls = element.enclosingElement;
+      if (!compiler.world.needsRti(cls)) return;
+      cls.typeVariables.forEach((TypeVariableType typeVariable) {
+        addBackendParameter(typeVariable.element, parameters, parameterNames);
+      });
+    } else if (element.isGenerativeConstructorBody()) {
+      // Put the parameter checks parameters.
+      Node node = element.implementation.parseNode(compiler);
+      ClosureClassMap closureData =
+          compiler.closureToClassMapper.getMappingForNestedFunction(node);
+      FunctionElement functionElement = element;
+      FunctionSignature params = functionElement.computeSignature(compiler);
+      TreeElements elements =
+          compiler.enqueuer.resolution.getCachedElements(element);
+      params.orderedForEachParameter((Element element) {
+        if (elements.isParameterChecked(element)) {
+          Element checkResultElement =
+              closureData.parametersWithSentinel[element];
+          addBackendParameter(checkResultElement, parameters, parameterNames);
+        }
+      });
+    }
   }
 
   CodeBuffer generateBailoutMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen-bailout", graph);
 
       Map<Element, String> parameterNames = getParameterNames(work);
       List<js.Parameter> parameters = <js.Parameter>[];
       parameterNames.forEach((element, name) {
         parameters.add(new js.Parameter(name));
       });
-      addTypeParameters(work.element, parameters, parameterNames);
+      addBackendParameters(work.element, parameters, parameterNames);
 
       SsaUnoptimizedCodeGenerator codegen = new SsaUnoptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
       js.Block body = new js.Block(<js.Statement>[]);
       if (codegen.setup != null) body.statements.add(codegen.setup);
       body.statements.add(codegen.body);
       js.Fun fun =
           buildJavaScriptFunction(work.element, codegen.newParameters, body);
@@ skipping 2833 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }