anchor.diff:    ///
     /// Note that [getGlobal] must have been called for the field beforehand.
     w.Global? getGlobalInitializedFlag(Field variable) {
  -    return globalInitializedFlag[variable];
  +    return _globalInitializedFlag[variable];
     }
   
     /// Emit code to read a static field.
     w.ValueType readGlobal(w.Instructions b, Field variable) {
       w.Global global = getGlobal(variable);
  -    w.BaseFunction? initFunction = globalInitializers[variable];
  +    w.BaseFunction? initFunction = _globalInitializers[variable];
       if (initFunction == null) {
         // Statically initialized
         b.global_get(global);
         return global.type.type;
       }
  -    w.Global? flag = globalInitializedFlag[variable];
  +    w.Global? flag = _globalInitializedFlag[variable];
       if (flag != null) {
         // Explicit initialization flag
         assert(global.type.type == initFunction.type.outputs.single);
  
positive.code:           if (type.nullable) {
              b.ref_null(heapType);
            } else {
              b.global_get(prepareDummyValue(type)!);
            }
          } else {
            throw "Unsupported global type ${type} ($type)";
  
negative.code: 
    /// 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) {
      if (type is w.RefType && !type.nullable) {
        w.HeapType heapType = type.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);
            }
            global = m.addGlobal(w.GlobalType(type, mutable: false));
            w.Instructions ib = global.initializer;
  