Mix salt into result signatures.

pkg/front_end/lib/src/incremental_kernel_generator_impl.dart

 // Copyright (c) 2017, 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 file.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/incremental_resolved_ast_generator.dart';
@@ skipping 27 matching lines @@
 }
 
 /// Implementation of [IncrementalKernelGenerator].
 ///
 /// TODO(scheglov) Update the documentation.
 ///
 /// Theory of operation: an instance of [IncrementalResolvedAstGenerator] is
 /// used to obtain resolved ASTs, and these are fed into kernel code generation
 /// logic.
 class IncrementalKernelGeneratorImpl implements IncrementalKernelGenerator {
+  /// The version of data format, should be incremented on every format change.
+  static const int DATA_VERSION = 1;
+
   /// The compiler options, such as the [FileSystem], the SDK dill location,
   /// etc.
   final ProcessedOptions _options;
 
   /// The object that knows how to resolve "package:" and "dart:" URIs.
   final TranslateUri _uriTranslator;
 
   /// The logger to report compilation progress.
   final PerformanceLog _logger;
 
   /// The current file system state.
   final FileSystemState _fsState;
 
   /// The byte storage to get and put serialized data.
   final ByteStore _byteStore;
 
   /// The URI of the program entry point.
   final Uri _entryPoint;
 
+  /// The salt to mix into all hashes used as keys for serialized data.
+  List<int> _salt;
+
   /// Latest compilation signatures produced by [computeDelta] for libraries.
-  final Map<Uri, String> _uriToLatestSignature = {};
+  final Map<Uri, String> _latestSignature = {};
 
   /// The set of absolute file URIs that were reported through [invalidate]
   /// and not checked for actual changes yet.
   final Set<Uri> _invalidatedFiles = new Set<Uri>();
 
   IncrementalKernelGeneratorImpl(
       this._options, this._uriTranslator, this._entryPoint)
       : _logger = _options.logger,
         _fsState = new FileSystemState(_options.fileSystem, _uriTranslator),
-        _byteStore = _options.byteStore;
+        _byteStore = _options.byteStore {
+    _computeSalt();
+  }
 
   @override
   Future<DeltaProgram> computeDelta(
       {Future<Null> watch(Uri uri, bool used)}) async {
     return await _logger.runAsync('Compute delta', () async {
       await _refreshInvalidatedFiles();
 
       // Ensure that the graph starting at the entry point is ready.
       FileState entryLibrary = await _fsState.getFile(_entryPoint);
 
@@ skipping 15 matching lines @@
           results.add(result);
         }
       });
 
       Program program = new Program(nameRoot: nameRoot);
 
       // Add affected libraries (with different signatures).
       for (_LibraryCycleResult result in results) {
         for (Library library in result.kernelLibraries) {
           Uri uri = library.importUri;
-          if (_uriToLatestSignature[uri] != result.signature) {
-            _uriToLatestSignature[uri] = result.signature;
+          if (_latestSignature[uri] != result.signature) {
+            _latestSignature[uri] = result.signature;
             program.libraries.add(library);
           }
         }
       }
 
       // TODO(scheglov) Add libraries which import changed libraries.
 
       return new DeltaProgram(program);
     });
   }
 
   @override
   void invalidate(Uri uri) {
     _invalidatedFiles.add(uri);
   }
 
   @override
   void invalidateAll() => unimplemented();
 
   /// Ensure that [dillTarget] includes the [cycle] libraries.  It already
   /// contains all the libraries that sorted before the given [cycle] in
   /// topological order.  Return the result with the cycle libraries.
   Future<_LibraryCycleResult> _compileCycle(
       CanonicalName nameRoot, DillTarget dillTarget, LibraryCycle cycle) async {
     return _logger.runAsync('Compile cycle $cycle', () async {
       String signature;
       {
         var signatureBuilder = new ApiSignature();
-        // TODO(scheglov) add salt
-        //    signature.addUint32List(_fsState._salt);
+        signatureBuilder.addBytes(_salt);
         Set<FileState> transitiveFiles = cycle.libraries
             .map((library) => library.transitiveFiles)
             .expand((files) => files)
             .toSet();
         signatureBuilder.addInt(transitiveFiles.length);
         for (var file in transitiveFiles) {
           signatureBuilder.addString(file.uri.toString());
           // TODO(scheglov) use API signature
           signatureBuilder.addBytes(file.contentHash);
         }
@@ skipping 90 matching lines @@
               }
             });
           } else {
             // TODO(scheglov) How to handle this?
           }
         }
       }
     } while (wasChanged);
   }
 
+  /// Compute salt and put into [_salt].
+  void _computeSalt() {
+    var saltBuilder = new ApiSignature();
+    saltBuilder.addInt(DATA_VERSION);
+    saltBuilder.addBool(_options.strongMode);
+    saltBuilder.addString(_entryPoint.toString());
+    _salt = saltBuilder.toByteList();
+  }
+
   /// Refresh all the invalidated files and update dependencies.
   Future<Null> _refreshInvalidatedFiles() async {
     await _logger.runAsync('Refresh invalidated files', () async {
       for (var fileUri in _invalidatedFiles) {
         var file = await _fsState.getFile(fileUri);
         await file.refresh();
       }
       _invalidatedFiles.clear();
     });
   }
@@ skipping 18 matching lines @@
   /// TODO(scheglov) Use API signatures.
   /// TODO(scheglov) Or use tree shaking and compute signatures of outlines.
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   _LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }