anchor.diff:  
     /// Returns whether the given function was provided by [getDummyFunction].
     bool isDummyFunction(w.BaseFunction function) {
  -    return dummyFunctions[function.type] == function;
  -  }
  -
  -  w.Global? prepareDummyValue(w.ValueType type) {
  +    return _dummyFunctions[function.type] == function;
  +  }
  +
  +  w.Global? _prepareDummyValue(w.ValueType type) {
       if (type is w.RefType && !type.nullable) {
         w.HeapType heapType = type.heapType;
  -      w.DefinedGlobal? global = dummyValues[heapType];
  +      w.DefinedGlobal? global = _dummyValues[heapType];
         if (global != null) return global;
         if (heapType is w.DefType) {
           if (heapType is w.StructType) {
             for (w.FieldType field in heapType.fields) {
  -            prepareDummyValue(field.type.unpacked);
  +            _prepareDummyValue(field.type.unpacked);
             }
             global = m.addGlobal(w.GlobalType(type, mutable: false));
             w.Instructions ib = global.initializer;
  
positive.code:           ib.ref_func(getDummyFunction(heapType));
            ib.end();
          }
          dummyValues[heapType] = global!;
        }
        return global;
      }
  
negative.code:     w.Instructions ib = dummyGlobal.initializer;
      ib.struct_new(structType);
      ib.end();
      _dummyValues[w.HeapType.any] = dummyGlobal;
      _dummyValues[w.HeapType.eq] = dummyGlobal;
      _dummyValues[w.HeapType.data] = dummyGlobal;
    }
  
    /// Provide a dummy function with the given signature. Used for empty entries
    /// in vtables and for dummy values of function reference type.
    w.DefinedFunction getDummyFunction(w.FunctionType type) {
      return _dummyFunctions.putIfAbsent(type, () {
        w.DefinedFunction function = m.addFunction(type, "#dummy function $type");
        w.Instructions b = function.body;
        b.unreachable();
  