anchor.diff:   *   potential target of this dynamic call.
    *
    * - In checked mode, after a type annotation, we have more
  - *   information on the type of an element (parameter, function,
  - *   local). TODO(ngeoffray): Implement this.
  + *   information on the type of a local.
    */
   class NarrowTypeInformation extends TypeInformation {
     final TypeMask typeAnnotation;
  
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:     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);
            }
          }
        });
      }
    }
  
  
  