// Copyright (c) 2021, 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.

// NOTE: THIS FILE IS GENERATED. DO NOT EDIT.
//
// Instead modify 'tools/experimental_features.yaml' and run
// 'dart pkg/front_end/tool/fasta.dart generate-experimental-flags' to update.

part of 'experimental_flags.dart';

/// An experiment flag including its fixed properties.
class ExperimentalFlag {
  /// The name of this flag as used in the --enable-experiment option.
  final String name;

  /// `true` if this experimental feature is enabled by default.
  ///
  /// When `true`, the feature can still be disabled in individual libraries
  /// with a language version below the [experimentEnabledVersion], and if not
  /// [isExpired], the feature can also be disabled by using a 'no-' prefix
  /// in the --enable-experiment option.
  final bool isEnabledByDefault;

  /// `true` if this feature can no longer be changed using the
  /// --enable-experiment option.
  ///
  /// Libraries can still opt out of the feature by using a language version
  /// below the [experimentEnabledVersion].
  final bool isExpired;
  final Version enabledVersion;

  /// The minimum version that supports this feature.
  ///
  /// If the feature is not enabled by default, this is the current language
  /// version.
  final Version experimentEnabledVersion;

  /// The minimum version that supports this feature in allowed libraries.
  ///
  /// Allowed libraries are specified in
  ///
  ///    sdk/lib/_internal/allowed_experiments.json
  final Version experimentReleasedVersion;

  const ExperimentalFlag(
      {required this.name,
      required this.isEnabledByDefault,
      required this.isExpired,
      required this.enabledVersion,
      required this.experimentEnabledVersion,
      required this.experimentReleasedVersion});
  static const ExperimentalFlag alternativeInvalidationStrategy =
      const ExperimentalFlag(
          name: 'alternative-invalidation-strategy',
          isEnabledByDefault: true,
          isExpired: true,
          enabledVersion: const Version(2, 18),
          experimentEnabledVersion: const Version(2, 18),
          experimentReleasedVersion: const Version(2, 18));

  static const ExperimentalFlag classModifiers = const ExperimentalFlag(
      name: 'class-modifiers',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 0),
      experimentEnabledVersion: const Version(3, 0),
      experimentReleasedVersion: const Version(3, 0));

  static const ExperimentalFlag constFunctions = const ExperimentalFlag(
      name: 'const-functions',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: defaultLanguageVersion);

  static const ExperimentalFlag constantUpdate2018 = const ExperimentalFlag(
      name: 'constant-update-2018',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 0),
      experimentEnabledVersion: const Version(2, 0),
      experimentReleasedVersion: const Version(2, 0));

  static const ExperimentalFlag constructorTearoffs = const ExperimentalFlag(
      name: 'constructor-tearoffs',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 15),
      experimentEnabledVersion: const Version(2, 15),
      experimentReleasedVersion: const Version(2, 15));

  static const ExperimentalFlag controlFlowCollections = const ExperimentalFlag(
      name: 'control-flow-collections',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 0),
      experimentEnabledVersion: const Version(2, 0),
      experimentReleasedVersion: const Version(2, 0));

  static const ExperimentalFlag enhancedEnums = const ExperimentalFlag(
      name: 'enhanced-enums',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 17),
      experimentEnabledVersion: const Version(2, 17),
      experimentReleasedVersion: const Version(2, 17));

  static const ExperimentalFlag extensionMethods = const ExperimentalFlag(
      name: 'extension-methods',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 6),
      experimentEnabledVersion: const Version(2, 6),
      experimentReleasedVersion: const Version(2, 6));

  static const ExperimentalFlag genericMetadata = const ExperimentalFlag(
      name: 'generic-metadata',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 14),
      experimentEnabledVersion: const Version(2, 14),
      experimentReleasedVersion: const Version(2, 14));

  static const ExperimentalFlag inferenceUpdate1 = const ExperimentalFlag(
      name: 'inference-update-1',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 18),
      experimentEnabledVersion: const Version(2, 18),
      experimentReleasedVersion: const Version(2, 18));

  static const ExperimentalFlag inferenceUpdate2 = const ExperimentalFlag(
      name: 'inference-update-2',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 2),
      experimentEnabledVersion: const Version(3, 2),
      experimentReleasedVersion: const Version(3, 2));

  static const ExperimentalFlag inferenceUpdate3 = const ExperimentalFlag(
      name: 'inference-update-3',
      isEnabledByDefault: true,
      isExpired: false,
      enabledVersion: const Version(3, 4),
      experimentEnabledVersion: const Version(3, 4),
      experimentReleasedVersion: const Version(3, 4));

  static const ExperimentalFlag inlineClass = const ExperimentalFlag(
      name: 'inline-class',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 3),
      experimentEnabledVersion: const Version(3, 3),
      experimentReleasedVersion: const Version(3, 3));

  static const ExperimentalFlag macros = const ExperimentalFlag(
      name: 'macros',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: const Version(3, 3));

  static const ExperimentalFlag namedArgumentsAnywhere = const ExperimentalFlag(
      name: 'named-arguments-anywhere',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 17),
      experimentEnabledVersion: const Version(2, 17),
      experimentReleasedVersion: const Version(2, 17));

  static const ExperimentalFlag nativeAssets = const ExperimentalFlag(
      name: 'native-assets',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: defaultLanguageVersion);

  static const ExperimentalFlag nonNullable = const ExperimentalFlag(
      name: 'non-nullable',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 12),
      experimentEnabledVersion: const Version(2, 12),
      experimentReleasedVersion: const Version(2, 10));

  static const ExperimentalFlag nonfunctionTypeAliases = const ExperimentalFlag(
      name: 'nonfunction-type-aliases',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 13),
      experimentEnabledVersion: const Version(2, 13),
      experimentReleasedVersion: const Version(2, 13));

  static const ExperimentalFlag patterns = const ExperimentalFlag(
      name: 'patterns',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 0),
      experimentEnabledVersion: const Version(3, 0),
      experimentReleasedVersion: const Version(3, 0));

  static const ExperimentalFlag records = const ExperimentalFlag(
      name: 'records',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 0),
      experimentEnabledVersion: const Version(3, 0),
      experimentReleasedVersion: const Version(3, 0));

  static const ExperimentalFlag resourceIdentifiers = const ExperimentalFlag(
      name: 'resource-identifiers',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: defaultLanguageVersion);

  static const ExperimentalFlag sealedClass = const ExperimentalFlag(
      name: 'sealed-class',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(3, 0),
      experimentEnabledVersion: const Version(3, 0),
      experimentReleasedVersion: const Version(3, 0));

  static const ExperimentalFlag setLiterals = const ExperimentalFlag(
      name: 'set-literals',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 0),
      experimentEnabledVersion: const Version(2, 0),
      experimentReleasedVersion: const Version(2, 0));

  static const ExperimentalFlag spreadCollections = const ExperimentalFlag(
      name: 'spread-collections',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 0),
      experimentEnabledVersion: const Version(2, 0),
      experimentReleasedVersion: const Version(2, 0));

  static const ExperimentalFlag superParameters = const ExperimentalFlag(
      name: 'super-parameters',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 17),
      experimentEnabledVersion: const Version(2, 17),
      experimentReleasedVersion: const Version(2, 17));

  static const ExperimentalFlag testExperiment = const ExperimentalFlag(
      name: 'test-experiment',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: defaultLanguageVersion);

  static const ExperimentalFlag tripleShift = const ExperimentalFlag(
      name: 'triple-shift',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 14),
      experimentEnabledVersion: const Version(2, 14),
      experimentReleasedVersion: const Version(2, 14));

  static const ExperimentalFlag unnamedLibraries = const ExperimentalFlag(
      name: 'unnamed-libraries',
      isEnabledByDefault: true,
      isExpired: true,
      enabledVersion: const Version(2, 19),
      experimentEnabledVersion: const Version(2, 19),
      experimentReleasedVersion: const Version(2, 19));

  static const ExperimentalFlag variance = const ExperimentalFlag(
      name: 'variance',
      isEnabledByDefault: false,
      isExpired: false,
      enabledVersion: defaultLanguageVersion,
      experimentEnabledVersion: defaultLanguageVersion,
      experimentReleasedVersion: defaultLanguageVersion);
}

/// Interface for accessing the global state of experimental features.
class GlobalFeatures {
  final Map<ExperimentalFlag, bool> explicitExperimentalFlags;
  final AllowedExperimentalFlags? allowedExperimentalFlags;
  final Map<ExperimentalFlag, bool>? defaultExperimentFlagsForTesting;
  final Map<ExperimentalFlag, Version>? experimentEnabledVersionForTesting;
  final Map<ExperimentalFlag, Version>? experimentReleasedVersionForTesting;

  GlobalFeatures(this.explicitExperimentalFlags,
      {this.allowedExperimentalFlags,
      this.defaultExperimentFlagsForTesting,
      this.experimentEnabledVersionForTesting,
      this.experimentReleasedVersionForTesting});

  GlobalFeature _computeGlobalFeature(ExperimentalFlag flag) {
    return new GlobalFeature(
        flag,
        isExperimentEnabled(flag,
            defaultExperimentFlagsForTesting: defaultExperimentFlagsForTesting,
            explicitExperimentalFlags: explicitExperimentalFlags));
  }

  LibraryFeature _computeLibraryFeature(
      ExperimentalFlag flag, Uri canonicalUri, Version libraryVersion) {
    return new LibraryFeature(
        flag,
        isExperimentEnabledInLibrary(flag, canonicalUri,
            defaultExperimentFlagsForTesting: defaultExperimentFlagsForTesting,
            explicitExperimentalFlags: explicitExperimentalFlags,
            allowedExperimentalFlags: allowedExperimentalFlags),
        getExperimentEnabledVersionInLibrary(
            flag, canonicalUri, explicitExperimentalFlags,
            allowedExperimentalFlags: allowedExperimentalFlags,
            defaultExperimentFlagsForTesting: defaultExperimentFlagsForTesting,
            experimentEnabledVersionForTesting:
                experimentEnabledVersionForTesting,
            experimentReleasedVersionForTesting:
                experimentReleasedVersionForTesting),
        isExperimentEnabledInLibraryByVersion(
            flag, canonicalUri, libraryVersion,
            defaultExperimentFlagsForTesting: defaultExperimentFlagsForTesting,
            explicitExperimentalFlags: explicitExperimentalFlags,
            allowedExperimentalFlags: allowedExperimentalFlags));
  }

  GlobalFeature? _alternativeInvalidationStrategy;
  GlobalFeature get alternativeInvalidationStrategy =>
      _alternativeInvalidationStrategy ??= _computeGlobalFeature(
          ExperimentalFlag.alternativeInvalidationStrategy);

  GlobalFeature? _classModifiers;
  GlobalFeature get classModifiers => _classModifiers ??=
      _computeGlobalFeature(ExperimentalFlag.classModifiers);

  GlobalFeature? _constFunctions;
  GlobalFeature get constFunctions => _constFunctions ??=
      _computeGlobalFeature(ExperimentalFlag.constFunctions);

  GlobalFeature? _constantUpdate2018;
  GlobalFeature get constantUpdate2018 => _constantUpdate2018 ??=
      _computeGlobalFeature(ExperimentalFlag.constantUpdate2018);

  GlobalFeature? _constructorTearoffs;
  GlobalFeature get constructorTearoffs => _constructorTearoffs ??=
      _computeGlobalFeature(ExperimentalFlag.constructorTearoffs);

  GlobalFeature? _controlFlowCollections;
  GlobalFeature get controlFlowCollections => _controlFlowCollections ??=
      _computeGlobalFeature(ExperimentalFlag.controlFlowCollections);

  GlobalFeature? _enhancedEnums;
  GlobalFeature get enhancedEnums =>
      _enhancedEnums ??= _computeGlobalFeature(ExperimentalFlag.enhancedEnums);

  GlobalFeature? _extensionMethods;
  GlobalFeature get extensionMethods => _extensionMethods ??=
      _computeGlobalFeature(ExperimentalFlag.extensionMethods);

  GlobalFeature? _genericMetadata;
  GlobalFeature get genericMetadata => _genericMetadata ??=
      _computeGlobalFeature(ExperimentalFlag.genericMetadata);

  GlobalFeature? _inferenceUpdate1;
  GlobalFeature get inferenceUpdate1 => _inferenceUpdate1 ??=
      _computeGlobalFeature(ExperimentalFlag.inferenceUpdate1);

  GlobalFeature? _inferenceUpdate2;
  GlobalFeature get inferenceUpdate2 => _inferenceUpdate2 ??=
      _computeGlobalFeature(ExperimentalFlag.inferenceUpdate2);

  GlobalFeature? _inferenceUpdate3;
  GlobalFeature get inferenceUpdate3 => _inferenceUpdate3 ??=
      _computeGlobalFeature(ExperimentalFlag.inferenceUpdate3);

  GlobalFeature? _inlineClass;
  GlobalFeature get inlineClass =>
      _inlineClass ??= _computeGlobalFeature(ExperimentalFlag.inlineClass);

  GlobalFeature? _macros;
  GlobalFeature get macros =>
      _macros ??= _computeGlobalFeature(ExperimentalFlag.macros);

  GlobalFeature? _namedArgumentsAnywhere;
  GlobalFeature get namedArgumentsAnywhere => _namedArgumentsAnywhere ??=
      _computeGlobalFeature(ExperimentalFlag.namedArgumentsAnywhere);

  GlobalFeature? _nativeAssets;
  GlobalFeature get nativeAssets =>
      _nativeAssets ??= _computeGlobalFeature(ExperimentalFlag.nativeAssets);

  GlobalFeature? _nonNullable;
  GlobalFeature get nonNullable =>
      _nonNullable ??= _computeGlobalFeature(ExperimentalFlag.nonNullable);

  GlobalFeature? _nonfunctionTypeAliases;
  GlobalFeature get nonfunctionTypeAliases => _nonfunctionTypeAliases ??=
      _computeGlobalFeature(ExperimentalFlag.nonfunctionTypeAliases);

  GlobalFeature? _patterns;
  GlobalFeature get patterns =>
      _patterns ??= _computeGlobalFeature(ExperimentalFlag.patterns);

  GlobalFeature? _records;
  GlobalFeature get records =>
      _records ??= _computeGlobalFeature(ExperimentalFlag.records);

  GlobalFeature? _resourceIdentifiers;
  GlobalFeature get resourceIdentifiers => _resourceIdentifiers ??=
      _computeGlobalFeature(ExperimentalFlag.resourceIdentifiers);

  GlobalFeature? _sealedClass;
  GlobalFeature get sealedClass =>
      _sealedClass ??= _computeGlobalFeature(ExperimentalFlag.sealedClass);

  GlobalFeature? _setLiterals;
  GlobalFeature get setLiterals =>
      _setLiterals ??= _computeGlobalFeature(ExperimentalFlag.setLiterals);

  GlobalFeature? _spreadCollections;
  GlobalFeature get spreadCollections => _spreadCollections ??=
      _computeGlobalFeature(ExperimentalFlag.spreadCollections);

  GlobalFeature? _superParameters;
  GlobalFeature get superParameters => _superParameters ??=
      _computeGlobalFeature(ExperimentalFlag.superParameters);

  GlobalFeature? _testExperiment;
  GlobalFeature get testExperiment => _testExperiment ??=
      _computeGlobalFeature(ExperimentalFlag.testExperiment);

  GlobalFeature? _tripleShift;
  GlobalFeature get tripleShift =>
      _tripleShift ??= _computeGlobalFeature(ExperimentalFlag.tripleShift);

  GlobalFeature? _unnamedLibraries;
  GlobalFeature get unnamedLibraries => _unnamedLibraries ??=
      _computeGlobalFeature(ExperimentalFlag.unnamedLibraries);

  GlobalFeature? _variance;
  GlobalFeature get variance =>
      _variance ??= _computeGlobalFeature(ExperimentalFlag.variance);
}

/// Interface for accessing the state of experimental features within a
/// specific library.
class LibraryFeatures {
  final GlobalFeatures globalFeatures;
  final Uri canonicalUri;
  final Version libraryVersion;

  LibraryFeatures(this.globalFeatures, this.canonicalUri, this.libraryVersion);

  LibraryFeature? _alternativeInvalidationStrategy;
  LibraryFeature get alternativeInvalidationStrategy =>
      _alternativeInvalidationStrategy ??=
          globalFeatures._computeLibraryFeature(
              ExperimentalFlag.alternativeInvalidationStrategy,
              canonicalUri,
              libraryVersion);

  LibraryFeature? _classModifiers;
  LibraryFeature get classModifiers =>
      _classModifiers ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.classModifiers, canonicalUri, libraryVersion);

  LibraryFeature? _constFunctions;
  LibraryFeature get constFunctions =>
      _constFunctions ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.constFunctions, canonicalUri, libraryVersion);

  LibraryFeature? _constantUpdate2018;
  LibraryFeature get constantUpdate2018 =>
      _constantUpdate2018 ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.constantUpdate2018, canonicalUri, libraryVersion);

  LibraryFeature? _constructorTearoffs;
  LibraryFeature get constructorTearoffs =>
      _constructorTearoffs ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.constructorTearoffs, canonicalUri, libraryVersion);

  LibraryFeature? _controlFlowCollections;
  LibraryFeature get controlFlowCollections =>
      _controlFlowCollections ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.controlFlowCollections,
          canonicalUri,
          libraryVersion);

  LibraryFeature? _enhancedEnums;
  LibraryFeature get enhancedEnums =>
      _enhancedEnums ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.enhancedEnums, canonicalUri, libraryVersion);

  LibraryFeature? _extensionMethods;
  LibraryFeature get extensionMethods =>
      _extensionMethods ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.extensionMethods, canonicalUri, libraryVersion);

  LibraryFeature? _genericMetadata;
  LibraryFeature get genericMetadata =>
      _genericMetadata ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.genericMetadata, canonicalUri, libraryVersion);

  LibraryFeature? _inferenceUpdate1;
  LibraryFeature get inferenceUpdate1 =>
      _inferenceUpdate1 ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.inferenceUpdate1, canonicalUri, libraryVersion);

  LibraryFeature? _inferenceUpdate2;
  LibraryFeature get inferenceUpdate2 =>
      _inferenceUpdate2 ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.inferenceUpdate2, canonicalUri, libraryVersion);

  LibraryFeature? _inferenceUpdate3;
  LibraryFeature get inferenceUpdate3 =>
      _inferenceUpdate3 ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.inferenceUpdate3, canonicalUri, libraryVersion);

  LibraryFeature? _inlineClass;
  LibraryFeature get inlineClass =>
      _inlineClass ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.inlineClass, canonicalUri, libraryVersion);

  LibraryFeature? _macros;
  LibraryFeature get macros =>
      _macros ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.macros, canonicalUri, libraryVersion);

  LibraryFeature? _namedArgumentsAnywhere;
  LibraryFeature get namedArgumentsAnywhere =>
      _namedArgumentsAnywhere ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.namedArgumentsAnywhere,
          canonicalUri,
          libraryVersion);

  LibraryFeature? _nativeAssets;
  LibraryFeature get nativeAssets =>
      _nativeAssets ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.nativeAssets, canonicalUri, libraryVersion);

  LibraryFeature? _nonNullable;
  LibraryFeature get nonNullable =>
      _nonNullable ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.nonNullable, canonicalUri, libraryVersion);

  LibraryFeature? _nonfunctionTypeAliases;
  LibraryFeature get nonfunctionTypeAliases =>
      _nonfunctionTypeAliases ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.nonfunctionTypeAliases,
          canonicalUri,
          libraryVersion);

  LibraryFeature? _patterns;
  LibraryFeature get patterns =>
      _patterns ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.patterns, canonicalUri, libraryVersion);

  LibraryFeature? _records;
  LibraryFeature get records =>
      _records ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.records, canonicalUri, libraryVersion);

  LibraryFeature? _resourceIdentifiers;
  LibraryFeature get resourceIdentifiers =>
      _resourceIdentifiers ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.resourceIdentifiers, canonicalUri, libraryVersion);

  LibraryFeature? _sealedClass;
  LibraryFeature get sealedClass =>
      _sealedClass ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.sealedClass, canonicalUri, libraryVersion);

  LibraryFeature? _setLiterals;
  LibraryFeature get setLiterals =>
      _setLiterals ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.setLiterals, canonicalUri, libraryVersion);

  LibraryFeature? _spreadCollections;
  LibraryFeature get spreadCollections =>
      _spreadCollections ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.spreadCollections, canonicalUri, libraryVersion);

  LibraryFeature? _superParameters;
  LibraryFeature get superParameters =>
      _superParameters ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.superParameters, canonicalUri, libraryVersion);

  LibraryFeature? _testExperiment;
  LibraryFeature get testExperiment =>
      _testExperiment ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.testExperiment, canonicalUri, libraryVersion);

  LibraryFeature? _tripleShift;
  LibraryFeature get tripleShift =>
      _tripleShift ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.tripleShift, canonicalUri, libraryVersion);

  LibraryFeature? _unnamedLibraries;
  LibraryFeature get unnamedLibraries =>
      _unnamedLibraries ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.unnamedLibraries, canonicalUri, libraryVersion);

  LibraryFeature? _variance;
  LibraryFeature get variance =>
      _variance ??= globalFeatures._computeLibraryFeature(
          ExperimentalFlag.variance, canonicalUri, libraryVersion);

  /// Returns the [LibraryFeature] corresponding to [experimentalFlag].
  LibraryFeature fromSharedExperimentalFlags(
      shared.ExperimentalFlag experimentalFlag) {
    switch (experimentalFlag) {
      case shared.ExperimentalFlag.classModifiers:
        return classModifiers;
      case shared.ExperimentalFlag.constFunctions:
        return constFunctions;
      case shared.ExperimentalFlag.constantUpdate2018:
        return constantUpdate2018;
      case shared.ExperimentalFlag.constructorTearoffs:
        return constructorTearoffs;
      case shared.ExperimentalFlag.controlFlowCollections:
        return controlFlowCollections;
      case shared.ExperimentalFlag.enhancedEnums:
        return enhancedEnums;
      case shared.ExperimentalFlag.extensionMethods:
        return extensionMethods;
      case shared.ExperimentalFlag.genericMetadata:
        return genericMetadata;
      case shared.ExperimentalFlag.inferenceUpdate1:
        return inferenceUpdate1;
      case shared.ExperimentalFlag.inferenceUpdate2:
        return inferenceUpdate2;
      case shared.ExperimentalFlag.inferenceUpdate3:
        return inferenceUpdate3;
      case shared.ExperimentalFlag.inlineClass:
        return inlineClass;
      case shared.ExperimentalFlag.macros:
        return macros;
      case shared.ExperimentalFlag.namedArgumentsAnywhere:
        return namedArgumentsAnywhere;
      case shared.ExperimentalFlag.nativeAssets:
        return nativeAssets;
      case shared.ExperimentalFlag.nonNullable:
        return nonNullable;
      case shared.ExperimentalFlag.nonfunctionTypeAliases:
        return nonfunctionTypeAliases;
      case shared.ExperimentalFlag.patterns:
        return patterns;
      case shared.ExperimentalFlag.records:
        return records;
      case shared.ExperimentalFlag.resourceIdentifiers:
        return resourceIdentifiers;
      case shared.ExperimentalFlag.sealedClass:
        return sealedClass;
      case shared.ExperimentalFlag.setLiterals:
        return setLiterals;
      case shared.ExperimentalFlag.spreadCollections:
        return spreadCollections;
      case shared.ExperimentalFlag.superParameters:
        return superParameters;
      case shared.ExperimentalFlag.testExperiment:
        return testExperiment;
      case shared.ExperimentalFlag.tripleShift:
        return tripleShift;
      case shared.ExperimentalFlag.unnamedLibraries:
        return unnamedLibraries;
      case shared.ExperimentalFlag.variance:
        return variance;
      default:
        throw new UnsupportedError(
            'LibraryFeatures.fromSharedExperimentalFlags($experimentalFlag)');
    }
  }
}

ExperimentalFlag? parseExperimentalFlag(String flag) {
  switch (flag) {
    case "alternative-invalidation-strategy":
      return ExperimentalFlag.alternativeInvalidationStrategy;
    case "class-modifiers":
      return ExperimentalFlag.classModifiers;
    case "const-functions":
      return ExperimentalFlag.constFunctions;
    case "constant-update-2018":
      return ExperimentalFlag.constantUpdate2018;
    case "constructor-tearoffs":
      return ExperimentalFlag.constructorTearoffs;
    case "control-flow-collections":
      return ExperimentalFlag.controlFlowCollections;
    case "enhanced-enums":
      return ExperimentalFlag.enhancedEnums;
    case "extension-methods":
      return ExperimentalFlag.extensionMethods;
    case "generic-metadata":
      return ExperimentalFlag.genericMetadata;
    case "inference-update-1":
      return ExperimentalFlag.inferenceUpdate1;
    case "inference-update-2":
      return ExperimentalFlag.inferenceUpdate2;
    case "inference-update-3":
      return ExperimentalFlag.inferenceUpdate3;
    case "inline-class":
      return ExperimentalFlag.inlineClass;
    case "macros":
      return ExperimentalFlag.macros;
    case "named-arguments-anywhere":
      return ExperimentalFlag.namedArgumentsAnywhere;
    case "native-assets":
      return ExperimentalFlag.nativeAssets;
    case "non-nullable":
      return ExperimentalFlag.nonNullable;
    case "nonfunction-type-aliases":
      return ExperimentalFlag.nonfunctionTypeAliases;
    case "patterns":
      return ExperimentalFlag.patterns;
    case "records":
      return ExperimentalFlag.records;
    case "resource-identifiers":
      return ExperimentalFlag.resourceIdentifiers;
    case "sealed-class":
      return ExperimentalFlag.sealedClass;
    case "set-literals":
      return ExperimentalFlag.setLiterals;
    case "spread-collections":
      return ExperimentalFlag.spreadCollections;
    case "super-parameters":
      return ExperimentalFlag.superParameters;
    case "test-experiment":
      return ExperimentalFlag.testExperiment;
    case "triple-shift":
      return ExperimentalFlag.tripleShift;
    case "unnamed-libraries":
      return ExperimentalFlag.unnamedLibraries;
    case "variance":
      return ExperimentalFlag.variance;
  }
  return null;
}

final Map<ExperimentalFlag, bool> defaultExperimentalFlags = {
  ExperimentalFlag.alternativeInvalidationStrategy:
      ExperimentalFlag.alternativeInvalidationStrategy.isEnabledByDefault,
  ExperimentalFlag.classModifiers:
      ExperimentalFlag.classModifiers.isEnabledByDefault,
  ExperimentalFlag.constFunctions:
      ExperimentalFlag.constFunctions.isEnabledByDefault,
  ExperimentalFlag.constantUpdate2018:
      ExperimentalFlag.constantUpdate2018.isEnabledByDefault,
  ExperimentalFlag.constructorTearoffs:
      ExperimentalFlag.constructorTearoffs.isEnabledByDefault,
  ExperimentalFlag.controlFlowCollections:
      ExperimentalFlag.controlFlowCollections.isEnabledByDefault,
  ExperimentalFlag.enhancedEnums:
      ExperimentalFlag.enhancedEnums.isEnabledByDefault,
  ExperimentalFlag.extensionMethods:
      ExperimentalFlag.extensionMethods.isEnabledByDefault,
  ExperimentalFlag.genericMetadata:
      ExperimentalFlag.genericMetadata.isEnabledByDefault,
  ExperimentalFlag.inferenceUpdate1:
      ExperimentalFlag.inferenceUpdate1.isEnabledByDefault,
  ExperimentalFlag.inferenceUpdate2:
      ExperimentalFlag.inferenceUpdate2.isEnabledByDefault,
  ExperimentalFlag.inferenceUpdate3:
      ExperimentalFlag.inferenceUpdate3.isEnabledByDefault,
  ExperimentalFlag.inlineClass: ExperimentalFlag.inlineClass.isEnabledByDefault,
  ExperimentalFlag.macros: ExperimentalFlag.macros.isEnabledByDefault,
  ExperimentalFlag.namedArgumentsAnywhere:
      ExperimentalFlag.namedArgumentsAnywhere.isEnabledByDefault,
  ExperimentalFlag.nativeAssets:
      ExperimentalFlag.nativeAssets.isEnabledByDefault,
  ExperimentalFlag.nonNullable: ExperimentalFlag.nonNullable.isEnabledByDefault,
  ExperimentalFlag.nonfunctionTypeAliases:
      ExperimentalFlag.nonfunctionTypeAliases.isEnabledByDefault,
  ExperimentalFlag.patterns: ExperimentalFlag.patterns.isEnabledByDefault,
  ExperimentalFlag.records: ExperimentalFlag.records.isEnabledByDefault,
  ExperimentalFlag.resourceIdentifiers:
      ExperimentalFlag.resourceIdentifiers.isEnabledByDefault,
  ExperimentalFlag.sealedClass: ExperimentalFlag.sealedClass.isEnabledByDefault,
  ExperimentalFlag.setLiterals: ExperimentalFlag.setLiterals.isEnabledByDefault,
  ExperimentalFlag.spreadCollections:
      ExperimentalFlag.spreadCollections.isEnabledByDefault,
  ExperimentalFlag.superParameters:
      ExperimentalFlag.superParameters.isEnabledByDefault,
  ExperimentalFlag.testExperiment:
      ExperimentalFlag.testExperiment.isEnabledByDefault,
  ExperimentalFlag.tripleShift: ExperimentalFlag.tripleShift.isEnabledByDefault,
  ExperimentalFlag.unnamedLibraries:
      ExperimentalFlag.unnamedLibraries.isEnabledByDefault,
  ExperimentalFlag.variance: ExperimentalFlag.variance.isEnabledByDefault,
};
const AllowedExperimentalFlags defaultAllowedExperimentalFlags =
    const AllowedExperimentalFlags(
        sdkDefaultExperiments: {},
        sdkLibraryExperiments: {},
        packageExperiments: {});
const Map<shared.ExperimentalFlag, ExperimentalFlag> sharedExperimentalFlags = {
  shared.ExperimentalFlag.classModifiers: ExperimentalFlag.classModifiers,
  shared.ExperimentalFlag.constFunctions: ExperimentalFlag.constFunctions,
  shared.ExperimentalFlag.constantUpdate2018:
      ExperimentalFlag.constantUpdate2018,
  shared.ExperimentalFlag.constructorTearoffs:
      ExperimentalFlag.constructorTearoffs,
  shared.ExperimentalFlag.controlFlowCollections:
      ExperimentalFlag.controlFlowCollections,
  shared.ExperimentalFlag.enhancedEnums: ExperimentalFlag.enhancedEnums,
  shared.ExperimentalFlag.extensionMethods: ExperimentalFlag.extensionMethods,
  shared.ExperimentalFlag.genericMetadata: ExperimentalFlag.genericMetadata,
  shared.ExperimentalFlag.inferenceUpdate1: ExperimentalFlag.inferenceUpdate1,
  shared.ExperimentalFlag.inferenceUpdate2: ExperimentalFlag.inferenceUpdate2,
  shared.ExperimentalFlag.inferenceUpdate3: ExperimentalFlag.inferenceUpdate3,
  shared.ExperimentalFlag.inlineClass: ExperimentalFlag.inlineClass,
  shared.ExperimentalFlag.macros: ExperimentalFlag.macros,
  shared.ExperimentalFlag.namedArgumentsAnywhere:
      ExperimentalFlag.namedArgumentsAnywhere,
  shared.ExperimentalFlag.nativeAssets: ExperimentalFlag.nativeAssets,
  shared.ExperimentalFlag.nonNullable: ExperimentalFlag.nonNullable,
  shared.ExperimentalFlag.nonfunctionTypeAliases:
      ExperimentalFlag.nonfunctionTypeAliases,
  shared.ExperimentalFlag.patterns: ExperimentalFlag.patterns,
  shared.ExperimentalFlag.records: ExperimentalFlag.records,
  shared.ExperimentalFlag.resourceIdentifiers:
      ExperimentalFlag.resourceIdentifiers,
  shared.ExperimentalFlag.sealedClass: ExperimentalFlag.sealedClass,
  shared.ExperimentalFlag.setLiterals: ExperimentalFlag.setLiterals,
  shared.ExperimentalFlag.spreadCollections: ExperimentalFlag.spreadCollections,
  shared.ExperimentalFlag.superParameters: ExperimentalFlag.superParameters,
  shared.ExperimentalFlag.testExperiment: ExperimentalFlag.testExperiment,
  shared.ExperimentalFlag.tripleShift: ExperimentalFlag.tripleShift,
  shared.ExperimentalFlag.unnamedLibraries: ExperimentalFlag.unnamedLibraries,
  shared.ExperimentalFlag.variance: ExperimentalFlag.variance,
};