Update FeatureSet to the new rules.

Bug: #43032
Change-Id: I6c7d7dc56fd0d4edcc3c6f6cc6fb0422316b8f4c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/159187
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analysis_server/lib/src/analysis_server_abstract.dart

@@ -35,6 +35,8 @@ import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart' as nd;
+import 'package:analyzer/src/dart/analysis/experiments.dart'
+    as analyzer_features;
 import 'package:analyzer/src/dart/analysis/file_byte_store.dart'
     show EvictingFileByteStore;
 import 'package:analyzer/src/dart/analysis/file_state.dart' as nd;
@@ -157,8 +159,10 @@ abstract class AbstractAnalysisServer {
     var pluginWatcher = PluginWatcher(resourceProvider, pluginManager);
 
     defaultContextOptions.contextFeatures =
-        analyzer_features.FeatureSet.fromEnableFlags(
-            options.enabledExperiments);
+        analyzer_features.FeatureSet.fromEnableFlags2(
+      sdkLanguageVersion: analyzer_features.ExperimentStatus.currentVersion,
+      flags: options.enabledExperiments,
+    );
     defaultContextOptions.useFastaParser = options.useFastaParser;
 
     {

pkg/analyzer/lib/dart/analysis/features.dart

@@ -64,9 +64,26 @@ abstract class FeatureSet {
 
   /// Computes the set of features implied by the given set of experimental
   /// enable flags.
+  @Deprecated("Use 'fromEnableFlags2' instead")
   factory FeatureSet.fromEnableFlags(List<String> flags) =
       ExperimentStatus.fromStrings;
 
+  /// Computes the set of features implied by the given set of experimental
+  /// enable flags.
+  factory FeatureSet.fromEnableFlags2({
+    @required Version sdkLanguageVersion,
+    @required List<String> flags,
+  }) = ExperimentStatus.fromStrings2;
+
+  /// Computes the set of features for the latest language version known
+  /// to the analyzer, without any experiments.  Use it only if you really
+  /// don't care which language version you want to use, and sure that the
+  /// code that you process is valid for the latest language version.
+  ///
+  /// Otherwise, it is recommended to use [FeatureSet.fromEnableFlags2].
+  factory FeatureSet.latestLanguageVersion() =
+      ExperimentStatus.latestLanguageVersion;
+
   /// Queries whether the given [feature] is contained in this feature set.
   bool isEnabled(Feature feature);
 

pkg/analyzer/lib/dart/analysis/utilities.dart

@@ -78,7 +78,7 @@ ParseStringResult parseString(
     FeatureSet featureSet,
     String path,
     bool throwIfDiagnostics = true}) {
-  featureSet ??= FeatureSet.fromEnableFlags([]);
+  featureSet ??= FeatureSet.latestLanguageVersion();
   var source = StringSource(content, path);
   var reader = CharSequenceReader(content);
   var errorCollector = RecordingErrorListener();

pkg/analyzer/lib/dart/sdk/build_sdk_summary.dart

@@ -158,7 +158,10 @@ class _Builder {
       if (pathSegments.isNotEmpty) {
         var libraryName = pathSegments.first;
         var experiments = allowedExperiments.forSdkLibrary(libraryName);
-        return FeatureSet.fromEnableFlags(experiments);
+        return FeatureSet.fromEnableFlags2(
+          sdkLanguageVersion: languageVersion,
+          flags: experiments,
+        );
       }
     }
     throw StateError('Expected a valid dart: URI: $uri');

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -85,7 +85,7 @@ typedef WorkToWaitAfterComputingResult = Future<void> Function(String path);
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 109;
+  static const int DATA_VERSION = 110;
 
   /// The length of the list returned by [_computeDeclaredVariablesSignature].
   static const int _declaredVariablesSignatureLength = 4;

pkg/analyzer/lib/src/dart/analysis/experiments.dart

@@ -20,52 +20,148 @@ export 'package:analyzer/src/dart/analysis/experiments_impl.dart'
 
 part 'experiments.g.dart';
 
-/// Gets access to the private list of boolean flags in an [Experiments] object.
-/// For testing use only.
+/// Gets access to the private list of boolean flags in an [ExperimentStatus]
+/// object. For testing use only.
 @visibleForTesting
 List<bool> getExperimentalFlags_forTesting(ExperimentStatus status) =>
-    status._enableFlags;
+    status._flags;
+
+/// Gets access to the private SDK language version in an [ExperimentStatus]
+/// object. For testing use only.
+@visibleForTesting
+Version getSdkLanguageVersion_forTesting(ExperimentStatus status) =>
+    status._sdkLanguageVersion;
 
 /// A representation of the set of experiments that are active and whether they
 /// are enabled.
 class ExperimentStatus with _CurrentState implements FeatureSet {
   /// The current language version.
   static final Version currentVersion = Version.parse(_currentVersion);
 
+  /// The language version to use in tests.
+  static final Version testingSdkLanguageVersion = Version.parse('2.10.0');
+
+  /// The latest known language version.
+  static final Version latestSdkLanguageVersion = Version.parse('2.10.0');
+
+  static final FeatureSet latestWithNullSafety = ExperimentStatus.fromStrings2(
+    sdkLanguageVersion: latestSdkLanguageVersion,
+    flags: [EnableString.non_nullable],
+  );
+
   /// A map containing information about all known experimental flags.
   static final Map<String, ExperimentalFeature> knownFeatures = _knownFeatures;
 
-  final List<bool> _enableFlags;
+  final Version _sdkLanguageVersion;
+  final List<bool> _explicitEnabledFlags;
+  final List<bool> _explicitDisabledFlags;
+  final List<bool> _flags;
 
-  /// Initializes a newly created set of experiments based on optional
-  /// arguments.
-  ExperimentStatus() : _enableFlags = _buildExperimentalFlagsArray();
+  factory ExperimentStatus() {
+    return ExperimentStatus.latestLanguageVersion();
+  }
 
   /// Computes a set of features for use in a unit test.  Computes the set of
   /// features enabled in [sdkVersion], plus any specified [additionalFeatures].
   ///
   /// If [sdkVersion] is not supplied (or is `null`), then the current set of
   /// enabled features is used as the starting point.
   @visibleForTesting
-  ExperimentStatus.forTesting(
-      {String sdkVersion, List<Feature> additionalFeatures = const []})
-      : this._(enableFlagsForTesting(
-            sdkVersion: sdkVersion, additionalFeatures: additionalFeatures));
+  factory ExperimentStatus.forTesting(
+      // ignore:avoid_unused_constructor_parameters
+      {String sdkVersion,
+      List<Feature> additionalFeatures = const []}) {
+    var explicitFlags = decodeExplicitFlags([]);
+    for (ExperimentalFeature feature in additionalFeatures) {
+      explicitFlags.enabled[feature.index] = true;
+    }
+
+    var sdkLanguageVersion = latestSdkLanguageVersion;
+    var flags = restrictEnableFlagsToVersion(
+      sdkLanguageVersion: sdkLanguageVersion,
+      explicitEnabledFlags: explicitFlags.enabled,
+      explicitDisabledFlags: explicitFlags.disabled,
+      version: sdkLanguageVersion,
+    );
+
+    return ExperimentStatus._(
+      sdkLanguageVersion,
+      explicitFlags.enabled,
+      explicitFlags.disabled,
+      flags,
+    );
+  }
+
+  factory ExperimentStatus.fromStorage(List<int> encoded) {
+    var allFlags = encoded.skip(2).map((e) => e != 0).toList();
+    var featureCount = allFlags.length ~/ 3;
+    return ExperimentStatus._(
+      Version(encoded[0], encoded[1], 0),
+      allFlags.sublist(0, featureCount),
+      allFlags.sublist(featureCount, featureCount * 2),
+      allFlags.sublist(featureCount * 2, featureCount * 3),
+    );
+  }
+
+  /// Decodes the strings given in [flags] into a representation of the set of
+  /// experiments that should be enabled.
+  ///
+  /// Always succeeds, even if the input flags are invalid.  Expired and
+  /// unrecognized flags are ignored, conflicting flags are resolved in favor of
+  /// the flag appearing last.
+  factory ExperimentStatus.fromStrings(List<String> flags) {
+    return ExperimentStatus.fromStrings2(
+      sdkLanguageVersion: latestSdkLanguageVersion,
+      flags: flags,
+    );
+  }
 
   /// Decodes the strings given in [flags] into a representation of the set of
   /// experiments that should be enabled.
   ///
   /// Always succeeds, even if the input flags are invalid.  Expired and
   /// unrecognized flags are ignored, conflicting flags are resolved in favor of
   /// the flag appearing last.
-  ExperimentStatus.fromStrings(List<String> flags) : this._(decodeFlags(flags));
+  factory ExperimentStatus.fromStrings2({
+    @required Version sdkLanguageVersion,
+    @required List<String> flags,
+    // TODO(scheglov) use restrictEnableFlagsToVersion
+  }) {
+    var explicitFlags = decodeExplicitFlags(flags);
+
+    var decodedFlags = restrictEnableFlagsToVersion(
+      sdkLanguageVersion: sdkLanguageVersion,
+      explicitEnabledFlags: explicitFlags.enabled,
+      explicitDisabledFlags: explicitFlags.disabled,
+      version: sdkLanguageVersion,
+    );
+
+    return ExperimentStatus._(
+      sdkLanguageVersion,
+      explicitFlags.enabled,
+      explicitFlags.disabled,
+      decodedFlags,
+    );
+  }
+
+  factory ExperimentStatus.latestLanguageVersion() {
+    return ExperimentStatus.fromStrings2(
+      sdkLanguageVersion: latestSdkLanguageVersion,
+      flags: [],
+    );
+  }
 
-  ExperimentStatus._(this._enableFlags);
+  ExperimentStatus._(
+    this._sdkLanguageVersion,
+    this._explicitEnabledFlags,
+    this._explicitDisabledFlags,
+    this._flags,
+  );
 
   @override
   int get hashCode {
     int hash = 0;
-    for (var flag in _enableFlags) {
+    for (var flag in _flags) {
       hash = JenkinsSmiHash.combine(hash, flag.hashCode);
     }
     return JenkinsSmiHash.finish(hash);
@@ -74,9 +170,19 @@ class ExperimentStatus with _CurrentState implements FeatureSet {
   @override
   bool operator ==(Object other) {
     if (other is ExperimentStatus) {
-      if (_enableFlags.length != other._enableFlags.length) return false;
-      for (int i = 0; i < _enableFlags.length; i++) {
-        if (_enableFlags[i] != other._enableFlags[i]) return false;
+      if (_sdkLanguageVersion != other._sdkLanguageVersion) {
+        return false;
+      }
+      if (!_equalListOfBool(
+          _explicitEnabledFlags, other._explicitEnabledFlags)) {
+        return false;
+      }
+      if (!_equalListOfBool(
+          _explicitDisabledFlags, other._explicitDisabledFlags)) {
+        return false;
+      }
+      if (!_equalListOfBool(_flags, other._flags)) {
+        return false;
       }
       return true;
     }
@@ -86,16 +192,42 @@ class ExperimentStatus with _CurrentState implements FeatureSet {
   /// Queries whether the given [feature] is enabled or disabled.
   @override
   bool isEnabled(covariant ExperimentalFeature feature) =>
-      _enableFlags[feature.index];
+      _flags[feature.index];
 
   @override
-  FeatureSet restrictToVersion(Version version) =>
-      ExperimentStatus._(restrictEnableFlagsToVersion(_enableFlags, version));
+  FeatureSet restrictToVersion(Version version) {
+    return ExperimentStatus._(
+      _sdkLanguageVersion,
+      _explicitEnabledFlags,
+      _explicitDisabledFlags,
+      restrictEnableFlagsToVersion(
+        sdkLanguageVersion: _sdkLanguageVersion,
+        explicitEnabledFlags: _explicitEnabledFlags,
+        explicitDisabledFlags: _explicitDisabledFlags,
+        version: version,
+      ),
+    );
+  }
+
+  /// Encode into the format suitable for [ExperimentStatus.fromStorage].
+  List<int> toStorage() {
+    return [
+      _sdkLanguageVersion.major,
+      _sdkLanguageVersion.minor,
+      ..._explicitEnabledFlags.map((e) => e ? 1 : 0),
+      ..._explicitDisabledFlags.map((e) => e ? 1 : 0),
+      ..._flags.map((e) => e ? 1 : 0),
+    ];
+  }
 
   @override
-  String toString() => experimentStatusToString(_enableFlags);
+  String toString() => experimentStatusToString(_flags);
 
-  /// Returns a list of strings suitable for passing to
-  /// [ExperimentStatus.fromStrings].
-  List<String> toStringList() => experimentStatusToStringList(this);
+  static bool _equalListOfBool(List<bool> first, List<bool> second) {
+    if (first.length != second.length) return false;
+    for (var i = 0; i < first.length; i++) {
+      if (first[i] != second[i]) return false;
+    }
+    return true;
+  }
 }

pkg/analyzer/lib/src/dart/analysis/experiments.g.dart

@@ -26,19 +26,6 @@ final _knownFeatures = <String, ExperimentalFeature>{
   EnableString.variance: ExperimentalFeatures.variance,
 };
 
-List<bool> _buildExperimentalFlagsArray() => <bool>[
-      true, // constant-update-2018
-      true, // control-flow-collections
-      true, // extension-methods
-      IsEnabledByDefault.non_nullable,
-      IsEnabledByDefault.nonfunction_type_aliases,
-      true, // set-literals
-      true, // spread-collections
-      IsEnabledByDefault.triple_shift,
-      IsEnabledByDefault.value_class,
-      IsEnabledByDefault.variance,
-    ];
-
 /// Constant strings for enabling each of the currently known experimental
 /// flags.
 class EnableString {