Add source information to the covariance checks inserted for strong mode

pkg/kernel/lib/transformations/insert_covariance_checks.dart

 // Copyright (c) 2016, 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 kernel.transformations.insert_covariance_checks;
 
 import '../class_hierarchy.dart';
 import '../clone.dart';
 import '../core_types.dart';
 import '../kernel.dart';
 import '../log.dart';
@@ skipping 359 matching lines @@
       var unsafeInputs = unsafeParameterTypes[parameter];
       if (unsafeInputs == null) {
         return new VariableGet(cloneParameter); // No check needed.
       }
       // Change the actual parameter type to the safe type, and cast to the
       // type declared on the original parameter.
       // Use the cloner to map function type parameters to the cloned
       // function type parameters (in case the function is generic).
       var targetType = cloneParameter.type;
       cloneParameter.type = cloner.visitType(getSafeType(unsafeInputs));
-      return new AsExpression(new VariableGet(cloneParameter), targetType);
+      return new AsExpression(new VariableGet(cloneParameter), targetType)
+          ..fileOffset = parameter.fileOffset;
     }
 
     // TODO: Insert checks for type parameter bounds.
     var types = checkedFunction.typeParameters
         .map((p) => new TypeParameterType(p))
         .toList();
     var positional = function.positionalParameters.map(getParameter).toList();
     var named = function.namedParameters
         .map((p) => new NamedExpression(p.name, getParameter(p)))
         .toList();
@@ skipping 18 matching lines @@
       global.unsafeMemberEntryPoint[procedure] = checkedProcedure;
     }
   }
 
   void generateCheckedFieldSetter(Field field) {
     var parameter = getFieldSetterParameter(field);
     var unsafeTypes = unsafeParameterTypes[parameter];
     Expression argument = new VariableGet(parameter);
     if (unsafeTypes != null) {
       var castType = substitute(field.type, ownSubstitution);
-      argument = new AsExpression(argument, castType);
+      argument = new AsExpression(argument, castType)
+          ..fileOffset = field.fileOffset;
       var inputType = substitute(getSafeType(unsafeTypes), ownSubstitution);
       parameter.type = inputType;
     }
 
     Statement body = field.isInExternalLibrary
         ? null
         : new ExpressionStatement(
             new DirectPropertySet(new ThisExpression(), field, argument));
 
     var setter = new Procedure(
         covariantCheckedName(field.name),
         ProcedureKind.Setter,
-        new FunctionNode(body, positionalParameters: [parameter]));
+        new FunctionNode(body, positionalParameters: [parameter]))
+      ..fileUri = field.fileUri;
     host.addMember(setter);
 
     if (field.enclosingClass == host) {
       global.unsafeMemberEntryPoint[field] = setter;
     }
   }
 
   /// Generates a synthetic name representing the covariant-checked entry point
   /// to a method.
   static Name covariantCheckedName(Name name) {
@@ skipping 70 matching lines @@
   @override
   visitPropertySet(PropertySet node) {
     var target = getChecked(node.receiver, node.interfaceTarget);
     if (target != null) {
       node.interfaceTarget = target;
       node.name = target.name;
     }
     node.visitChildren(this);
   }
 }