anchor.diff:      refine();
   
       compiler.log('Inferred $overallRefineCount types.');
  +
  +    if (compiler.enableTypeAssertions) {
  +      // Undo the narrowing of parameters types. Parameters are being
  +      // checked by the method, and we can therefore only trust their
  +      // type after the checks. It is okay for the inferrer to rely on
  +      // the type annotations, but the backend should has to
  +      // insert the checks.
  +      types.typeInformations.forEach((Element element,
  +                                      ElementTypeInformation info) {
  +        if (element.isParameter() || element.isFieldParameter()) {
  +          if (info.abandonInferencing) {
  +            info.type = types.dynamicType.type;
  +          } else {
  +            info.type = types.computeTypeMask(info.assignments);
  +          }
  +        }
  +      });
  +    }
     }
   
   
  
positive.code:     return null;
    }
  
    TypeMask refine(TypeGraphInferrerEngine inferrer) {
      TypeMask special = handleSpecialCases(inferrer);
      if (special != null) return special;
      return inferrer.types.computeTypeMask(assignments);
    }
  
    TypeMask refineOptimistic(TypeGraphInferrerEngine inferrer) {
      TypeMask special = handleSpecialCases(inferrer);
      if (special != null) return special;
      return inferrer.types.computeTypeMask(
          assignments.where((e) => e.isConcrete));
    }
  
    String toString() => 'Element $element';
  
negative.code:  *   potential target of this dynamic call.
   *
   * - In checked mode, after a type annotation, we have more
   *   information on the type of a local.
   */
  class NarrowTypeInformation extends TypeInformation {
    final TypeMask typeAnnotation;
  