anchor.diff:    final ProcessedOptions options =
         new ProcessedOptions(options: optionBuilder, inputs: [entryPoint]);
   
  +  final CompilerOptions optionBuilderNoNNBD = new CompilerOptions()
  +    ..target = new VmTarget(new TargetFlags())
  +    ..verbose = true
  +    ..omitPlatform = true
  +    ..fileSystem = fs
  +    ..sdkSummary = sdkSummary
  +    ..onDiagnostic = (DiagnosticMessage message) {
  +      printDiagnosticMessage(message, print);
  +      errors.add(message);
  +    }
  +    ..environmentDefines = const {}
  +    ..explicitExperimentalFlags = {ExperimentalFlag.nonNullable: false}
  +    ..allowedExperimentalFlagsForTesting = const AllowedExperimentalFlags();
  +
  +  final ProcessedOptions optionsNoNNBD =
  +      new ProcessedOptions(options: optionBuilderNoNNBD, inputs: [entryPoint]);
  +
     final bool updateExpectations = environment["updateExpectations"] == "true";
   
     final bool fuzz = environment["fuzz"] == "true";
   
     final CompilerContext compilerContext = new CompilerContext(options);
  +  final CompilerContext compilerContextNoNNBD =
  +      new CompilerContext(optionsNoNNBD);
   
     // Disable colors to ensure that expectation files are the same across
     // platforms and independent of stdin/stderr.
     colors.enableColors = false;
   
  -  return new Context(compilerContext, errors, updateExpectations, fuzz);
  +  return new Context(
  +      compilerContext, compilerContextNoNNBD, errors, updateExpectations, fuzz);
   }
   
   void main([List<String> arguments = const []]) =>
  
positive.code:     }
  
      if (context.fuzz) {
        await fuzz(compiler, compilerResult, context);
      }
    }
  
    Future<void> fuzz(IncrementalCompiler compiler,
        IncrementalCompilerResult compilerResult, Context context) async {
      for (Library lib in compilerResult.classHierarchy!.knownLibraries) {
        if (!context.fuzzedLibraries.add(lib.importUri)) continue;
  
        for (Member m in lib.members) {
          await fuzzMember(m, compiler, lib.importUri, context);
        }
  
        for (Class c in lib.classes) {
          for (Member m in c.members) {
            await fuzzMember(m, compiler, lib.importUri, context);
          }
        }
      }
    }
  
    Future<void> fuzzMember(Member m, IncrementalCompiler compiler,
        Uri libraryUri, Context context) async {
      String expression = m.name.text;
      if (m is Field || (m is Procedure && m.isGetter)) {
        // fields and getters are fine as-is
  
negative.code:     }
    }
  
    Future<void> fuzzTryCompile(
        IncrementalCompiler compiler,
        IncrementalCompiler compilerNoNNBD,
        String expression,
        Uri libraryUri,
        String? className,
        bool isStatic,
        Context context) async {
      context.fuzzCompiles++;
      print("Fuzz compile #${context.fuzzCompiles} "
          "('$expression' in $libraryUri $className)");
      {
        Procedure? compiledProcedure = await compiler.compileExpression(
          expression,
          {},
          [],
          "debugExpr",
          libraryUri,
          className: className,
          isStatic: isStatic,
        );
        context.takeErrors();
        if (compiledProcedure != null) {
          // Confirm we can serialize generated procedure.
          List<int> list = serializeProcedure(compiledProcedure);
          assert(list.length > 0);
        }
      }
      {
        Procedure? compiledProcedure = await compilerNoNNBD.compileExpression(
          expression,
          {},
          [],
          "debugExpr",
          libraryUri,
          className: className,
          isStatic: isStatic,
        );
        context.takeErrors();
        if (compiledProcedure != null) {
          // Confirm we can serialize generated procedure.
          List<int> list = serializeProcedure(compiledProcedure);
          assert(list.length > 0);
        }
      }
    }
  
  