Separate updateComments from updateExpectations.

pkg/front_end/test/fasta/testing/suite.dart

 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 library fasta.testing.suite;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File;
 
@@ skipping 69 matching lines @@
 class FastaContext extends ChainContext {
   final TranslateUri uriTranslator;
   final List<Step> steps;
   final Uri vm;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
   Future<Program> platform;
 
-  FastaContext(this.vm, bool strongMode, bool updateExpectations,
-      this.uriTranslator, bool fullCompile, AstKind astKind)
+  FastaContext(
+      this.vm,
+      bool strongMode,
+      bool updateExpectations,
+      bool updateComments,
+      this.uriTranslator,
+      bool fullCompile,
+      AstKind astKind)
       : steps = <Step>[
           new Outline(fullCompile, astKind, strongMode,
-              updateExpectations: updateExpectations),
+              updateComments: updateComments),
           const Print(),
           new Verify(fullCompile),
           new MatchExpectation(
               fullCompile
                   ? ".${shortenAstKindName(astKind, strongMode)}.expect"
                   : ".outline.expect",
               updateExpectations: updateExpectations)
         ] {
     if (fullCompile) {
       steps.add(const WriteDill());
       steps.add(const Run());
     }
   }
 
   Future<Program> loadPlatform() {
     return platform ??= new Future<Program>(() async {
       Uri sdk = await computePatchedSdk();
       return loadProgramFromBinary(sdk.resolve('platform.dill').toFilePath());
     });
   }
 
   static Future<FastaContext> create(
       Chain suite, Map<String, String> environment) async {
     Uri sdk = await computePatchedSdk();
     Uri vm = computeDartVm(sdk);
     Uri packages = Uri.base.resolve(".packages");
     TranslateUri uriTranslator = await TranslateUri.parse(packages);
     bool strongMode = environment.containsKey(STRONG_MODE);
     bool updateExpectations = environment["updateExpectations"] == "true";
+    bool updateComments = environment["updateComments"] == "true";
     String astKindString = environment[AST_KIND_INDEX];
     AstKind astKind =
         astKindString == null ? null : AstKind.values[int.parse(astKindString)];
-    return new FastaContext(vm, strongMode, updateExpectations, uriTranslator,
-        environment.containsKey(ENABLE_FULL_COMPILE), astKind);
+    return new FastaContext(vm, strongMode, updateExpectations, updateComments,
+        uriTranslator, environment.containsKey(ENABLE_FULL_COMPILE), astKind);
   }
 }
 
 class Run extends Step<Uri, int, FastaContext> {
   const Run();
 
   String get name => "run";
 
   bool get isAsync => true;
 
@@ skipping 14 matching lines @@
 }
 
 class Outline extends Step<TestDescription, Program, FastaContext> {
   final bool fullCompile;
 
   final AstKind astKind;
 
   final bool strongMode;
 
   const Outline(this.fullCompile, this.astKind, this.strongMode,
-      {this.updateExpectations: false});
+      {this.updateComments: false});
 
-  final bool updateExpectations;
+  final bool updateComments;
 
   String get name {
     return fullCompile ? "${astKind} compile" : "outline";
   }
 
   bool get isCompiler => fullCompile;
 
   Future<Result<Program>> run(
       TestDescription description, FastaContext context) async {
     Program platform = await context.loadPlatform();
@@ skipping 14 matching lines @@
       if (strongMode) {
         instrumentation = new ValidatingInstrumentation();
         await instrumentation.loadExpectations(description.uri);
         sourceTarget.loader.instrumentation = instrumentation;
       }
       p = await sourceTarget.writeOutline(null);
       if (fullCompile) {
         p = await sourceTarget.writeProgram(null);
         instrumentation?.finish();
         if (instrumentation != null && instrumentation.hasProblems) {
-          if (updateExpectations) {
+          if (updateComments) {
             await instrumentation.fixSource(description.uri);
           } else {
             return fail(null, instrumentation.problemsAsString);
           }
         }
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
     return pass(p);
   }
 }