anchor.diff:   * instance methods within a single compilation unit.
    */
   class InstanceMemberInferrer {
  -  //
  -  // Previously, all of our analysis tasks have had the property that they only
  -  // set fields in the element model that were previously null, and they express
  -  // all their dependencies using the task model. That had the advantage that
  -  // if a subtle dependency change causes us to re-execute some tasks that we've
  -  // executed previously, we can be confident that the results from the previous
  -  // execution won't pollute the results of the re-execution.
  -  //
  -  // The algorithm in this class doesn't have that property, since it decides
  -  // which types to infer based on looking for types that are "dynamic", and
  -  // then it *replaces* those types with the inferred types.  This means that if
  -  // type inference is re-run, it won't re-infer already-inferred types. There
  -  // is concern that a situation could arising where, for example, class A
  -  // extends class B, and a change to class B requires inference to be re-run on
  -  // class A, but since class A has already had inference run on it once before,
  -  // it will not re-infer properly.
  -  //
  -  // This probably isn't a problem today because changing class B will cause
  -  // class A's element model to be re-built from scratch (wiping out any
  -  // inference results), but one day we might try to make things more
  -  // incremental, and that could cause subtle breakages. Similar problems might
  -  // arise if the type of a declaration in class A is in turn inferred from some
  -  // other elements.
  -  //
  -  // In the future we might want the element model to keep track of a
  -  // "preliminary type" distinct from the "static type" in order to avoid these
  -  // problems.
  -  //
  -
     /**
      * The type provider used to look up types.
      */
  
positive.code:           newType = fieldElement.initializer.returnType;
          }
        }
        if (newType != null && !newType.isBottom) {
          (fieldElement as FieldElementImpl).type = newType;
          _setReturnType(fieldElement.getter, newType);
          _setParameterType(fieldElement.setter, newType);
        }
      }
    }
  
  
negative.code:   void _inferField(FieldElement fieldElement) {
      if (!fieldElement.isSynthetic &&
          !fieldElement.isStatic &&
          fieldElement.hasImplicitType) {
        //
        // First look for overridden getters with the same name as the field.
        //
  