Add operators test to source_mapping_test.

pkg/compiler/lib/src/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 SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 474 matching lines @@
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
           builder.compiler.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
           builder.compiler.internalError(local,
               "Cannot find value $local.");
         }
       }
-      return directLocals[local];
+      HInstruction value = directLocals[local];
+      if (sourceInformation != null) {
+        value = new HRef(value, sourceInformation);
+        builder.add(value);
+      }
+      return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
       HInstruction receiver = readLocal(closureData.closureElement);
       TypeMask type = local is BoxLocal
           ? builder.backend.nonNullType
           : builder.getTypeOfCapturedVariable(redirect);
       HInstruction fieldGet = new HFieldGet(redirect, receiver, type);
       builder.add(fieldGet);
       return fieldGet..sourceInformation = sourceInformation;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       HInstruction box = readLocal(redirect.box);
       HInstruction lookup = new HFieldGet(
           redirect, box, builder.getTypeOfCapturedVariable(redirect));
       builder.add(lookup);
       return lookup..sourceInformation = sourceInformation;
     } else {
       assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       HInstruction instruction = new HLocalGet(
-          local, localValue, builder.backend.dynamicType);
+          local, localValue, builder.backend.dynamicType, sourceInformation);
       builder.add(instruction);
-      return instruction..sourceInformation = sourceInformation;
+      return instruction;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisLocal);
     if (res.instructionType == null) {
       res.instructionType = builder.getTypeOfThis();
     }
     return res;
   }
@@ skipping 21 matching lines @@
       return new TypeVariableLocal(type, executableContext);
     });
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
   void updateLocal(Local local, HInstruction value,
                    {SourceInformation sourceInformation}) {
+    if (value is HRef) {
+      HRef ref = value;
+      value = ref.value;
+    }
     assert(!isStoredInClosureField(local));
     if (isAccessedDirectly(local)) {
       directLocals[local] = value;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       HInstruction box = readLocal(redirect.box);
@@ skipping 1067 matching lines @@
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
             visitCondition: () {
               HParameterValue parameter = parameters.values.first;
               push(new HIdentity(
                   parameter, graph.addConstantNull(compiler), null,
                   backend.boolType));
             },
             visitThen: () {
-              // TODO(johnniwinther): Add source information.
               closeAndGotoExit(new HReturn(
                   graph.addConstantBool(false, compiler),
-                  null));
+                  sourceInformationBuilder
+                      .buildImplicitReturn(functionElement)));
             },
-            visitElse: null);
+            visitElse: null,
+            sourceInformation: sourceInformationBuilder.buildIf(function.body));
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildCheckedSetter(VariableElement field) {
     openFunction(field, field.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
@@ skipping 3222 matching lines @@
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
         typeMask: backend.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
-    assert(stack.last is HInvokeStatic || stack.last == newObject);
+    assert(invariant(
+        CURRENT_ELEMENT_SPANNABLE,
+        stack.last is HInvokeStatic || stack.last == newObject,
+        message:
+          "Unexpected `stack.last`: Found ${stack.last}, "
+          "expected ${newObject} or an HInvokeStatic. "
+          "State: element=$element, rtiInputs=$rtiInputs, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
     bool isFixedList = false;
     bool isFixedListConstructorCall =
@@ skipping 3948 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }