Stub implementation of patch invariants for the patch refactoring.

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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name => 'SSA code generator';
   NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter;
 
 
   js.Fun buildJavaScriptFunction(FunctionElement element,
                                  List<js.Parameter> parameters,
                                  js.Block body) {
-    FunctionExpression expression = element.cachedNode;
+    FunctionExpression expression =
+        element.implementation.parseNode(backend.compiler);
     js.Fun result = new js.Fun(parameters, body);
     // TODO(johnniwinther): remove the 'element.patch' hack.
     Element sourceElement = element.patch == null ? element : element.patch;
     SourceFile sourceFile = sourceElement.getCompilationUnit().script.file;
     // TODO(podivilov): find the right sourceFile here and remove offset checks
     // below.
     if (expression.getBeginToken().charOffset < sourceFile.text.length) {
       result.sourcePosition = new SourceFileLocation(
           sourceFile, expression.getBeginToken());
     }
@@ skipping 36 matching lines @@
       graph.exit.predecessors.forEach((block) {
         assert(block.last is HGoto || block.last is HReturn);
         if (block.last is HReturn) {
           backend.registerReturnType(work.element, types[block.last.inputs[0]]);
         } else {
           backend.registerReturnType(work.element, HType.NULL);
         }
       });
       compiler.tracer.traceGraph("codegen", graph);
       Map<Element, String> parameterNames = getParameterNames(work);
-      parameterNames.forEach((element, name) {
+      // Use [work.element] to ensure that the parameter element come from
+      // the declaration.
+      work.element.computeSignature(compiler).forEachParameter((element) {
         compiler.enqueuer.codegen.addToWorkList(element);
       });
       List<js.Parameter> parameters = <js.Parameter>[];
       parameterNames.forEach((element, name) {
         parameters.add(new js.Parameter(name));
       });
       addTypeParameters(work.element, parameters, parameterNames);
       String parametersString = Strings.join(parameterNames.getValues(), ", ");
       SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
@@ skipping 62 matching lines @@
       if (codegen.setup != null) body.statements.add(codegen.setup);
       body.statements.add(codegen.body);
       js.Fun fun =
           buildJavaScriptFunction(work.element, codegen.newParameters, body);
       return prettyPrint(fun);
     });
   }
 
   Map<Element, String> getParameterNames(WorkItem work) {
     Map<Element, String> parameterNames = new LinkedHashMap<Element, String>();
-    FunctionElement function = work.element;
+    FunctionElement function = work.element.implementation;
 
     // The dom/html libraries have inline JS code that reference
     // parameter names directly. Long-term such code will be rejected.
     // Now, just don't mangle the parameter name.
     function.computeSignature(compiler).forEachParameter((Element element) {
       parameterNames[element] = function.isNative()
           ? element.name.slowToString()
           : JsNames.getValid('${element.name.slowToString()}');
     });
     return parameterNames;
@@ skipping 2819 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }