anchor.diff:      // TODO(paulberry): get the actual callee function type from the inference
       // engine
       var calleeType = const DynamicType();
  -    _replaceType(calleeType, expression.fileOffset);
  +    _replaceType(calleeType);
       _recordType(inferredType, expression.arguments.fileOffset);
       super.genericExpressionExit("staticInvocation", expression, inferredType);
     }
   
     @override
     void variableDeclarationEnter(VariableDeclaration statement) {
  -    _deferredTypeSlots.add(_recordType(null, statement.fileOffset));
  +    _deferType(statement.fileOffset);
       super.variableDeclarationEnter(statement);
     }
   
     @override
     void variableDeclarationExit(
         VariableDeclaration statement, DartType inferredType) {
  -    _replaceType(inferredType, statement.fileOffset);
  +    _replaceType(inferredType);
       super.variableDeclarationExit(statement, inferredType);
  +  }
  +
  +  /// Record `null` as the type at the given [offset], and put the current
  +  /// slot into the [_deferredTypeSlots] stack.
  +  void _deferType(int offset) {
  +    int slot = _recordType(null, offset);
  +    _deferredTypeSlots.add(slot);
     }
   
     int _recordType(DartType type, int offset) {
  
positive.code:   }
  
    @override
    void _replaceType(DartType type, int offset) {
      if (_debug) {
        print('Replacing type $type for offset $offset');
      }
      super._replaceType(type, offset);
    }
  }
  
  
negative.code:   static const bool _debug = false;
  
    final List<int> _typeOffsets;
    final List<int> _deferredOffsets = [];
  
    InstrumentedResolutionStorer(List<DartType> types, this._typeOffsets)
        : super(types);
  
    @override
    void _deferType(int offset) {
      super._deferType(offset);
      if (_debug) {
        _deferredOffsets.add(offset);
      }
    }
  
    @override
    int _recordType(DartType type, int offset) {
  